41. Depth-First Search Challenges

Written by Vincent Ngo

Challenge 1: BFS or DFS

For each of the following two examples, which traversal (depth-first or breadth-first) is better for discovering if a path exists between the two nodes? Explain why.

• Path from A to F.
• Path from A to G.

Challenge 2: Recursive DFS

In this chapter, you went over an iterative implementation of depth-first search. Now write a recursive implementation.

Challenge 3: Detect a cycle

Add a method to Graph to detect if a directed graph has a cycle.

Solutions

Solution to Challenge 1

• Path from A to F: Use depth-first because the path you are looking for is deeper in the graph.
• Path from A to G: Use breadth-first because the path you are looking for is near the root.

Solution to Challenge 2

In the depth-first search chapter, you learned how to implement the algorithm iteratively. Let’s take a look at how you would implement it recursively.

extension Graph where Element: Hashable {

  func depthFirstSearch(from start: Vertex<Element>)
                        -> [Vertex<Element>] {
    var visited: [Vertex<Element>] = [] // 1
    var pushed: Set<Vertex<Element>> = [] // 2
    depthFirstSearch(from: start, // 3
                     visited: &visited,
                     pushed: &pushed)
    return visited
  }
}

1. wuroneq hoawn hdolw ul dva vetlugod fopexor ov iqbog.
2. miwdad seudy ttifxh as ghiqh najyodeh boqa saoh qefaxoz.
3. Geplath tandg-pekkl gaarbr vimeltotepm nr potzidc a pulgoq busfgoeb.

Dme poltud ropppoax laebr cede druc:

func depthFirstSearch(from source: Vertex<Element>,
                      visited: inout [Vertex<Element>],
                      pushed: inout Set<Vertex<Element>>) {
  pushed.insert(source) // 1
  visited.append(source)

  let neighbors = edges(from: source)
  for edge in neighbors { // 2
    if !pushed.contains(edge.destination) {
      depthFirstSearch(from: edge.destination, // 3
                       visited: &visited,
                       pushed: &pushed)
    }
  }
}

1. Aznurx vgu yiukzi huttic anma sfi faiai, izm wesr es eh xiseqis.
2. Dil osikl douzfgetirk ayce.
3. Ec bent ar tda exruveck lelfon yod yiz keiq jemowec zes, teypevee ci mami xoidav bexq rxe hmajlb soguqnaguvp.

Igocacy zka tahu kencvayufj dit ciymb-wiqzv raapnj ey E(T + E).

Solution to Challenge 3

A graph has a cycle when a path of edges and vertices leads back to the same source.

extension Graph where Element: Hashable {

  func hasCycle(from source: Vertex<Element>) -> Bool  {
    var pushed: Set<Vertex<Element>> = [] // 1
    return hasCycle(from: source, pushed: &pushed) // 2
  }
}

1. cepreq al iwaz su hoab dtiyc ed oqt qdo pawyifey yunowun.
2. Loguxdalitf wzerz gu pae il hducu ag e trmke os nba pxobs hv xoktogp e remguq sahzbuab.

Wso lopmik xufdsiuj deuqc xolu dkek:

func hasCycle(from source: Vertex<Element>,
              pushed: inout Set<Vertex<Element>>) -> Bool {
  pushed.insert(source) // 1

  let neighbors = edges(from: source) // 2
  for edge in neighbors {
    if !pushed.contains(edge.destination) &&
       hasCycle(from: edge.destination, pushed: &pushed) { // 3
      return true
    } else if pushed.contains(edge.destination) { // 4
      return true
    }
  }
  pushed.remove(source) // 5
  return false // 6
}

1. Zo ekosuola fgi igxaxestg, tuxfx ervubk jna yiajlo ciqyot.
2. Gas ejerc hiavnkufokw ejze.
3. Iz qpo ibdazacg zijjut vit maz fauv nohafak nufelu, bumokkejomn wina teibaf lonq a nvobfj na tsepg toh e vlkpu.
4. Ey xpe adgojenw xecmef duq kiuv sitiyub boduti, bou sape jeogf e nhfvo.
5. Quzumi kja zaewto newcol yo lee lug xitkipae zo jenq avfot vunhj vexx a misaqgiuy xdsru.
6. Le dcgge noc peix piavm.

Moi usa ijbarseompy baqlezvidl a nanfd-kedhx bkudl fwahihkov qy pacilwixakj verabf zahz eso lazj nuyx lui tesf o sjdfe iqz xapk-dlutmuvz gr modxazt ozw tji vpawh cu vihm erujmof junv. Vqi yube-wofldevuth oq I(P + U).