BFS使用2个队列查找二维矩阵的最短路径

Question

What I'm trying to do:

Using a graph found in a text file, find and print the shortest path (minimum amount of vertices) from vertex A to vertex B.

Current implementation:

public String findPath(int v, int w) {
    Queue<Integer> q = new LinkedList<Integer>();
    boolean[] visited = new boolean[g.numVertices()];
    String[] pathTo = new String[g.numVertices()];

    q.add(v);
    pathTo[v] = v+" ";
    while(q.peek() != null) {
        if(runBFS(q.poll(),w,visited,q,pathTo))
        break;
    }
    return pathTo[w];
}

private boolean runBFS(int v, int w, boolean[] visited, Queue<Integer> q, String[] pathTo) {
    if(visited[v]) {
    }
    else if(v == w)
        return true; 
    }
    else {
        visited[v] = true;
        VertexIterator vi = g.adjacentVertices(v);
        while(vi.hasNext()) {
            int nextVertex = vi.next();
            pathTo[nextVertex] = pathTo[v] + nextVertex + " ";
            q.add(nextVertex);
        }
    }
    return false;
}

v = vertex of origin

w = target vertex

g = graph

vi = a normal iterator that iterates over the neighbours of v

Right now , it is using String[] to trace the paths but I was suggested that there is a solution to do this with Queue<ArrayList<Integer>> rather than String[] when saving paths by running this queue in parallel with the q queue.

Could someone guide me through this ?

Answer 1

You can use a second queue Queue<ArrayList<Integer>> q2 to store the shortest path (as an ArrayList<Integer> ) from v to each node currently in q in the same order. Whenever you poll q , you also poll q2 , and whenever you add a node to q , you calculate the shortest path to that node by copying the shortest path to the previous node and appending the current node, and add it to q2 .

Note, however, that copying the shortest path may take time linear in the number of vertices, which will increase the overall complexity. For this reason I wouldn't recommend this approach. Instead, for each node n you can store the previous node you came from when you visited n. As soon as you reach the target node w, you can then backtrack through these previous nodes to find the shortest path from the start node.