如何在线性时间内找到无向图中不同最短路径的数量？

Question

给定一条无向路径，在输入起始节点 u 和结束节点 v 后，不同最短路径数的算法是什么？该算法可以依赖于 |V|和 |E|，但必须是线性的。

证明它实际上返回任何 u 和 v 的不同最短路径的数量也会很有帮助。

Answer 1

在广度优先搜索 (BFS) 的第 n 次迭代中，我们将所有顶点添加到 与根距离为 n 的队列。一旦我们遇到 目的节点，我们找到了最短距离，即 n。为了 跟踪我们需要维护最短计数的每个节点的所有可能路径的数量 我们走的路。在下图中，我们看到有 20 个可能的最短 从 u 到 v 的路径。当我们遇到一个未访问的节点时，我们总结了 它的前身路径。

该算法跟踪所有访问过的节点及其计数。每次迭代 访问一组新节点并更新它们的计数。 Q 持有所有节点 在上一次迭代中访问过，N 保存在中遇到的新节点 当前迭代。

for all w in V {  // initialize count's and visited
    count[w] = 0
    visited[w] = false
}

Q.insert(u)
count[u] = 1      // start node (one path from u to u)
visited[u] = true

while true { 

   N = empty      // N = find all nodes adjacent to nodes in Q
   while not Q.empty() {
       w = Q.remove()
       for x adjacent to w {
            if not visited[x] {
               count[x] = count[x] + count[w] // found another path
               N.insert(x)
            }
       }
   }

   if N.empty() return 0  // never reached v

   if v in N() return count[v]  // reached v : return count

   remove duplicates in N  // avoid double counting in next iteration

   for w in N              // mark all nodes in N as visited
       visited[w] = true;

    Q = N                  // prepare for next iteration
}

Answer 2

我认为您正在寻找这样的东西：

注意：图存储为邻接表

public int shortestPath(int u, int v, ArrayList<Integer>[] adj) {
    Queue<Integer> bfs = new ArrayDeque();
    bfs.add(u);

    int ret = 0;

    boolean[] visited = new boolean[adj.length];

    while (!bfs.isEmpty() && (ret == 0 || bfs.peek() == v)) {
        int node = bfs.poll();
        visited[node] = true;

        if (node == v) {
            ret++;
        }

        for (int next : adj[node]) {
            if (!visited[next]) {
                bfs.add(next);
            }
        }
    }
    return ret;
}

这些想法在 cmets 中，但本质上你正在运行一个 bfs，并跟踪当第一个路径访问 v 时有多少路径访问 v。请注意我是如何将节点设置为仅在我从队列中轮询它之后才访问的，这是计算路径数所需要的。

如果您仍然感到困惑，请告诉我