1 单点最短路径
单点最短路径。 给定一幅图和一个起点s，回答“从s到给定目的顶点v是否存在一条路径？如果有，找出其中最短的那条（所含边数最少）。“等类似问题。
深度优先搜索在这个问题上没有什么作为，因为它遍历整个图的顺序和找出最短路径的目标没有任何关系。相比之下，广度优先搜索正好可以解决这个问题。
分析：
- 要找的从s到v的最短路径，从s开始，在所有由一条边就可以到达的顶点中寻找v，找到标记结束。
- 如果没有找到，我们继续在于s距离2条边的顶点中查找v，如此一直进行。
- 最后也没有找到，那么说明s到给定顶点v不存在路径，此图为非连通图。
结构选择：
- 广度优先搜索中，我们希望按照与起点的距离顺序遍历所有顶点，所以我们选择队列（先入先出）。
2 广度优先搜索实现
实现代码如下：
package com.gaogzhen.datastructure.graph.undirected;
import edu.princeton.cs.algs4.*;
/**
* 最短路径算法
* @author: Administrator
* @createTime: 2023/03/07 21:04
*/
public class BreadthFirstDirectedPaths {
private static final int INFINITY = Integer.MAX_VALUE;
/**
* 标记顶点是否与起点连通
*/
private boolean[] marked;
/**
* 表示顶点到与该顶点连通的顶点间最短路径
*/
private int[] edgeTo;
/**
* 顶点到起点之间的边数
*/
private int[] distTo;
/**
* 计算从指定顶点到起点最短路径
* @param G 无向图
* @param s 起点
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public BreadthFirstDirectedPaths(Graph G, int s) {
marked = new boolean[G.V()];
distTo = new int[G.V()];
edgeTo = new int[G.V()];
for (int v = 0; v < G.V(); v++) {
distTo[v] = INFINITY;
edgeTo[v] = -1;
}
validateVertex(s);
bfs(G, s);
}
/**
* 计算多个起点到指定顶点之间的最短路径
* @param G 无向图
* @param sources 多个起点集合
* @throws IllegalArgumentException if {@code sources} is {@code null}
* @throws IllegalArgumentException unless each vertex {@code v} in
* {@code sources} satisfies {@code 0 <= v < V}
*/
public BreadthFirstDirectedPaths(Graph G, Iterable<Integer> sources) {
marked = new boolean[G.V()];
distTo = new int[G.V()];
edgeTo = new int[G.V()];
for (int v = 0; v < G.V(); v++) {
distTo[v] = INFINITY;
edgeTo[v] = -1;
}
validateVertices(sources);
bfs(G, sources);
}
/**
* 广度优先搜索从指定顶点到起点最短路径
* @param G 无向图
* @param s 起点
*/
private void bfs(Graph G, int s) {
Queue<Integer> q = new Queue<Integer>();
marked[s] = true;
distTo[s] = 0;
q.enqueue(s);
while (!q.isEmpty()) {
int v = q.dequeue();
for (int w : G.adj(v)) {
if (!marked[w]) {
edgeTo[w] = v;
distTo[w] = distTo[v] + 1;
marked[w] = true;
q.enqueue(w);
}
}
}
}
// BFS from multiple sources
private void bfs(Graph G, Iterable<Integer> sources) {
Queue<Integer> q = new Queue<Integer>();
for (int s : sources) {
marked[s] = true;
distTo[s] = 0;
q.enqueue(s);
}
while (!q.isEmpty()) {
int v = q.dequeue();
for (int w : G.adj(v)) {
if (!marked[w]) {
edgeTo[w] = v;
distTo[w] = distTo[v] + 1;
marked[w] = true;
q.enqueue(w);
}
}
}
}
/**
* 起点s与指定顶点v之间是否有路径（连通）
* @param v the vertex
* @return {@code true} if there is a directed path, {@code false} otherwise
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public boolean hasPathTo(int v) {
validateVertex(v);
return marked[v];
}
/**
* 返回指定顶点v到起点直接的最短路径（边数）}?
* @param v the vertex
* @return the number of edges in such a shortest path
* (or {@code Integer.MAX_VALUE} if there is no such path)
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public int distTo(int v) {
validateVertex(v);
return distTo[v];
}
/**
* 返回指定顶点v到起点直接的最短路径，没有返回null
* @param v the vertex
* @return the sequence of vertices on a shortest path, as an Iterable
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public Iterable<Integer> pathTo(int v) {
validateVertex(v);
if (!hasPathTo(v)) return null;
Stack<Integer> path = new Stack<Integer>();
int x;
for (x = v; distTo[x] != 0; x = edgeTo[x])
path.push(x);
path.push(x);
return path;
}
// throw an IllegalArgumentException unless {@code 0 <= v < V}
private void validateVertex(int v) {
int V = marked.length;
if (v < 0 || v >= V)
throw new IllegalArgumentException("vertex " + v + " is not between 0 and " + (V-1));
}
// throw an IllegalArgumentException if vertices is null, has zero vertices,
// or has a vertex not between 0 and V-1
private void validateVertices(Iterable<Integer> vertices) {
if (vertices == null) {
throw new IllegalArgumentException("argument is null");
}
int V = marked.length;
int count = 0;
for (Integer v : vertices) {
count++;
if (v == null) {
throw new IllegalArgumentException("vertex is null");
}
validateVertex(v);
}
if (count == 0) {
throw new IllegalArgumentException("zero vertices");
}
}
}
队列保存所有已被标记但其邻接表未被检查过的顶点。先将起点加入队列，然后重复一下步骤知道队列为空。
- 取出队列中的下一个顶点v并标记它。
- 将与v相邻的所有未被标记过的顶点加入队列。
说明：
- edgeTo[]数组结果，也是一棵用父链接表示的根结点为s的树
- 多起点中，则以各自起点为根结点的树组成的森林。
- distTo[]表示到起点的路径长度，即边数。代码distTo[w] = distTo[v] + 1;当前顶点路径长度为其父顶点路径长度+1，起点为0。
- 与算法第四版不同的地方只是在初始化edgeTo为-1表示根结点；算法第四版默认都是0。
以之前无向图（6个顶点，8条边）为例单起点搜索索引起点为0（单起点的路径结果：
多起点（0,2）搜索结果如下图所示：
多起点搜索很少用到，一般情况下我们讨论最短路径默认为单点最短路径。
3 总结
命题B。对于从s可达的任意顶点v，广度优先搜索都能找到一条从s到v的最短路径（没有其他从s到v的路径所含有的边比这条路径少。
证明：由归纳易得队列总是包含林哥或者多个到起点的距离为k的顶点，之后是零个或者多个到起点为k+1的顶点，k为整数，起始值为0.这意味着顶点是按照它们和s的距离顺序加入或者离开队列。从顶点v加入队列到它离开队列之前，不可能找出到v的更短路径，而在v离开队列之后发现的所有能够到达v的路径都不可能短于v在树中的路径长度。
命题B（续）。广度优先搜索所需的时间在最坏情况下和V+E成正比。
证明：广度优先搜索标记所有与s连通的顶点所需的时间与它们的度数之和成正比。如果图是连通的，这个和就是所有顶点的度数之和，也就是2E。
广度优先搜索也可以解决单点连通问题，它检查所有与起点连通的顶点和边的方法取决于查找的能力。代码如下：
private void bfs(Graph G, int s) {
Queue<Integer> q = new Queue<Integer>();
marked[s] = true;
q.enqueue(s);
while (!q.isEmpty()) {
int v = q.dequeue();
for (int w : G.adj(v)) {
if (!marked[w]) {
marked[w] = true;
q.enqueue(w);
}
}
}
}
后记
如果小伙伴什么问题或者指教，欢迎交流。
❓QQ:806797785
⭐️源代码仓库地址：https://gitee.com/gaogzhen/algorithm
参考链接:
[1][美]Robert Sedgewich,[美]Kevin Wayne著;谢路云译.算法：第4版[M].北京：人民邮电出版社，2012.10.p344-348.
