Problems

1. Given a starting vertex s, find all vertices that are accessible from it.
2. Find a path (of some condition) from the starting vertex to a given destination vertex.
3. Given a directed graph and two vertices, find the lowest length path between them using forward breadth-first search from the starting vertex.
4. Given a directed graph and two vertices, find the lowest length path between them using backward breadth-first search from the ending vertex.
5. Find the connected components of an undirected graph using a depth-first traversal of the graph.
6. Find the connected components of an undirected graph using a breadth-first traversal of the graph.
7. Find the strongly-connected components of a directed graph in O(n+m) (n=no. of vertices, m=no. of arcs).
8. Find the bi-connected components of an undirected graph in O(n+m)
9. Use a lowest length path algorithm and solve the following problem:

• Wolf, goat and cabbage problem: A man has a wolf, a goat and a cabbage and must cross a river in a boat than can hold him and only one of the three items. He cannot leave alone the wolf with the goat or the goat with the cabbage. Find a shortest sequence of moves for crossing the river.
• Cannibals and missionairs: Three cannibals and three missionairs must cross a river using a boat that can carry at most two people. It is not allowed to have, at any moment and on any bank, the missionairs outnumbered by the cannibals (unless no missionairs exist on that bank at that time). Again, find a shortest sequence of moves for crossing the river.
• Jealous husbands: Three married couples must cross a river, using a using a boat that can carry at most two people. It is not allowed that any woman be, on a bank or on the boat, in the presence of a man, unless her husband is at the same place. Again, find a shortest sequence of moves for crossing the river.
• 15 puzzle

BFS

Input:
    G: graph
    s: a vertex
Output:
    accessible: the set of vertices that are accessible from s
    prev: a map that maps each accessible vertex to its predecessor on a path from s to it

Algorithm:
    Queue q
    Dictionary prev
    Dictionary dist
    Set visited
    q.enqueue(s)
    visited.add(s)
    dist[s] = 0

    while not q.isEmpty() do
        x = q.dequeue()

        for y in Nout(x) do
            if y not in visited then
                q.enqueue(y)
                visited.add(y)
                dist[y] = dist[x] + 1
                prev[y] = x
            end if
        end for
    end while

    accessible = visited

DFS

Input:
    G: graph
    s: a vertex

Output:
    accessible: the set of vertices that are accessible from s
    prev: a map that maps each accessible vertex to its predecessor on a path from s to it

Algorithm:
    Stack stack
    Dictionary prev
    Set visited
    stack.push(s)
    visited.add(s)
    prev[s] = null
    
    while not stack.isEmpty() do
        x = stack.pop()
        
        for y in Nout(x) do
            if y not in visited then
                stack.push(y)
                visited.add(y)
                prev[y] = x
            end if
        end for
    end while
    
    accessible = visited
    
    return accessible, prev