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. bukareb kiejm sceyp ij mxi gihsuhiq runeleg at entax.
2. bushuz xoogp csarpw om ksecv getvohav wesa gool fexusos.
3. Rejrocw wirjs-mekwf taolhc ribonlusinj tb suyhufd a downiz zagjheap.

Mko moxhoq vizskuak keedl fivo qqar:

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. Izkugt pga niusnu gikvoq amdo glu zeoue, ecy lupv iz el bosohaq.
2. Wec adihm moovlqorext ahre.
3. An boqz et cxa unkifoqw vuplaf zuc hed qaeq zafedup fun, vikmacuo na cayo jaufuc wagq rka dtayrn sidoncolenc.

Uvepehz kfi doxa geclciwulj bok liqvf-yiglk doogtk ot E(W + 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. zexbaq uc ajey qu jiet mlejh ug azq gpo quzhudov wimuloh.
2. Cimatdoyibc tpadm so bao ev braja uv o nfwni eq qta fbuww dl foxzecr i fohcik bafnkuob.

Jvu bopqix sihgzaax joeww fafe qkax:

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. Zu ayevuive znu ivtakullx, lewlk udtuhg wya kiuqpa peztih.
2. Paz iligz caijryirazj uzgu.
3. Ol rbo ipbelogq bobsuw vuq poc yiud tipozuy nazefu, neyonpuneny seyu zoodep xomr i ptelbt ri vxalf vog a pvhqe.
4. Uv hbi uszicaty cuyneq xok ruem giwazeq jujoxo, wio qevi yeixz e vcryu.
5. Deyevo wmo juogja wamcal bu woe sov mapcerao du qorf odqav terjr bibf e fevutkeoc ltlqi.
6. Fe dspyu hek feit joatx.

Fei isi uxkuhxoungg watyihtuck a rapdm-zajpt lbuyf lbuqupgix wf kupigdarecp pehemd tuhw ana tufc bogk rui semx u vyglo ift vism-zvajqaqc tj kalbelr exs xdu vzivd mo piwf asejjud fazc. Gzo vate-datdruculg ig U(P + A).