【数据结构】最短路径问题（BFS/DFS算法，Dijkstra算法，Floyd算法，Bellman-Ford算法）

BFS算法——严格层序的BFS

核心思路

原生广度优先遍历的特点本来就是由源点向外发散，我们通过对队列大小的暂存，可以实现严格的按层遍历，层数即路径长度。

适用场景

因为本算法将层数看作路径长度，所以这要求图的所有边要么无权、要么权值相等。

单源的；可以求到某一个点的最短路径，也可以求到所有点的最短路径。

代码实现

private void DFS(boolean[][] graph, int source) {
	int len = graph.length;
	int[] dist = new int[len];                          // dist[i]含义为从源点到i的最短距离

	ArrayDeque<Integer> queue = new ArrayDeque<>();     // 用于BFS的队列
	queue.offer(source);
	boolean[] visited = new boolean[len];               // visited[]记录是否已被访问过
	visited[source] = true;

	int layer = 1;                                      // 层数(即最短路径)初始化为1
	while (!queue.isEmpty()) {
		int size = queue.size();                        // 缓存一下队列的大小，这是严格层序BFS的关键
		for (int i = 0; i < size; i++) {
			int cur = queue.poll();
			for (int nxt = 0; nxt < len; nxt++) {
				if (graph[cur][nxt] && !visited[nxt]) {
					queue.offer(nxt);
					dist[nxt] = layer;
					visited[nxt] = true;
				}
			}
		}
		layer++;                                        // 每次出队"一层"，层数+1
	}
}

 
 
 

DFS算法——回溯写法的DFS

核心思路

原生深度优先遍历适合于可达性分析，而最短路径问题需要在所有可达的路径找一个最短的，因此使用DFS的回溯写法。

适用场景

本算法显然适用于带权图（事实上，除了上面的那个BFS，接下来的所有算法都适用于带权图，不再赘述）。

单源的；适合于求到某一个点的最短路径，不适合求到所有点的最短路径，除非你使用记忆化数组。

代码实现

private void DFS(int[][] graph, int pos, int target, int dist, boolean[] visited) {
	// 剪枝
	if (dist > minDist) {
		return;
	}
	// 尝试更新最短距离
	if (pos == target) {
		minDist = Math.min(minDist, dist);
		return;
	}
	// 深搜
	for (int i = 0; i < graph.length; i++) {
		if (graph[pos][i] > 0 && !visited[i]) {
			visited[i] = true;
			DFS(graph, i, target, dist + graph[pos][i], visited);
			visited[i] = false;
		}
	}
}

 
 
 

Dijkstra算法——每次固定一个最短距离的贪心

核心思路

用一个dist[]数组维护所有点到源点的最短距离，每次选出距源点最近的顶点k，然后修改与k相关的dist[]的值；这个过程进行 n-1 次，从而让所有的顶点都用于维护dist[]数组一次。

适用场景

每一次都固定一个到k的距离dist[k]，之后就不再修改它，但是负权边的出现会破坏贪心的正确性（看图）。所以，Dijkstra算法不适合于出现负权边的场景。

代码实现

private void Dijkstra(int[][] graph, int source) {
	int len = graph.length;
	// dist[i]的含义是源点到i的最短距离，对其初始化
	int[] dist = new int[len];
	for (int j = 0; j < len; j++) {
		dist[j] = graph[source][j];
	}

    // 记录是否被访问过的数组
    boolean[] visited = new boolean[len];
    visited[source] = true;

    // 执行n-1次，就贪心过了所有的顶点
    for (int i = 0; i < len - 1; i++) {
        // 1.寻找距源点最近的顶点k
        int minDist = Integer.MAX_VALUE;
        int k = -1;
        for (int j = 0; j < len; j++) {
            if (!visited[j] && graph[source][j] < minDist) {
                minDist = graph[source][j];
                k = j;
            }
        }
        // 2.固定k
        dist[k] = minDist;
        visited[k] = true;
        // 3.修改与k相关的距离
        for (int j = 0; j < len; j++) {
            if (!visited[j] && dist[k] + graph[k][j] < dist[j]) {
                dist[j] =  dist[k] + graph[k][j];
            }
        }
    }
}

 
 
 

Floyd算法——多源的路径压缩

核心思路

思路优美，代码简单，尝试用k作为中转更新从i到j的最短路径。

适用场景

与其他最短路径算法相比，Floyd算法最大的特点是它维护的多源的最短路径，也因此Floyd算法的时间复杂度为O(n³)，Dijkstra算法的时间复杂度是O(n²)——它相当于在每个顶点用一次Dijkstra。

Floyd算法允许图中出现负权边，但不允许负权边成环（看下图理解）。

代码实现

private void Floyd(int[][] graph) {
	int len = graph.length;
	// 一定注意，k一定写在第一层，目的是防止graph[i][j]过早固定！！！
	for (int k = 0; k < len; k++) {
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len; j++) {
				if (graph[i][k] + graph[k][j] < graph[i][j]) {
					graph[i][j] = graph[i][k] + graph[k][j];
				}
			}
		}
	}
}

 
 
 

Bellman-Ford算法——还是单源的路径压缩

核心思路

对dist[]进行n-1次压缩。

适用场景

Bellman-Ford算法的最大特点就是允许出现负权边成环，因为它可以检测出来。

Floyd算法是对graph[][]进行压缩，Bellman-Ford算法是对dist[]进行压缩，所以他们的时间复杂度分别是O(n³)和O(n²)。

代码实现

private void BellmanFord(int[] dist, Edge[] edges) {
	int len = dist.length;
	for (int i = 0; i < len - 1; i++) {                                   // 该过程进行n-1次
		for (int j = 0; j < len; j++) {                                   // Dijkstra的更新思路
			if (dist[edges[j].u] + edges[j].cost < dist[edges[j].v]) {
				dist[edges[j].v] = dist[edges[j].u] + edges[j].cost;
			}
		}
	}
}

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

☘️