查找未加权图中从源到目标的所有最短路径

Question

I'd like to find all shortest path in an unweighted graph. In my first attempt I managed to find only one short path using BFS. I used a stack to save the shortest path and a queue for BFS. The visited vector is used to mark if a node is visited or not. This is what I've done in Java:

public ArrayList<Integer> BFS(int source, int dest) {
        ArrayList<Integer> shortestPathList = new ArrayList<Integer>();
        boolean[] visited = new boolean[100];

        Queue<Integer> q = new LinkedList<Integer>();
        Stack<Integer> pathStack = new Stack<Integer>();

        q.add(source);
        pathStack.add(source);
        visited[source] = true;

        while (!q.isEmpty()) {
            int u = q.poll();
            for (int v : graph.getNeighboursOf(u)) {
                if (!visited[v]) {
                    q.add(v);
                    visited[v] = true;
                    pathStack.add(v);
                    if (u == dest)
                        break;
                }
            }
        }

        // To find the path
        int node, currentSrc = dest;
        shortestPathList.add(dest);
        while (!pathStack.isEmpty()) {
            node = pathStack.pop();
            if (graph.isNeighbor(currentSrc, node)) {
                shortestPathList.add(node);
                currentSrc = node;
                if (node == source)
                    break;
            }
        }

        return shortestPathList;
    }

The ArrayList shortestPathList contains only one short path. Can I modify this BFS to find all the shortest paths or I need to make another algorithm?

Answer 1

In your code,

if (!visited[v]) {...}

ensures you'll only use the first shortest path to each v. Instead of ignoring the others, you'll need to consider all of them (and you'll need to when the source is reached as long as paths of the same length are possible).

If you keep track of the minimal distance of visited nodes from the source, then this will find all shortest paths to the destination:

function shortest_paths_to(dest):

    if dest == source:
        yield path([n])
        return

    for each vertex n in neighbours(dest):

        if distance_from_source(n) < distance_from_source(dest):
           for each path p in shortest_paths_to(n):
               p.append(dest)
               yield p