算法工程师第五十三天（Floyd 算法精讲 A * 算法精讲（A star算法）最短路算法总结图论总结）

最新推荐文章于 2024-09-27 23:28:13 发布

LookCodes

最新推荐文章于 2024-09-27 23:28:13 发布

阅读量882

点赞数 22

文章标签：图论

本文链接：https://blog.csdn.net/rgz147123/article/details/141827076

版权

参考文献代码随想录

一、小明逛公园（Floyd 算法精讲）

题目描述

小明喜欢去公园散步，公园内布置了许多的景点，相互之间通过小路连接，小明希望在观看景点的同时，能够节省体力，走最短的路径。

给定一个公园景点图，图中有 N 个景点（编号为 1 到 N），以及 M 条双向道路连接着这些景点。每条道路上行走的距离都是已知的。

小明有 Q 个观景计划，每个计划都有一个起点 start 和一个终点 end，表示他想从景点 start 前往景点 end。由于小明希望节省体力，他想知道每个观景计划中从起点到终点的最短路径长度。请你帮助小明计算出每个观景计划的最短路径长度。

输入描述

第一行包含两个整数 N, M, 分别表示景点的数量和道路的数量。

接下来的 M 行，每行包含三个整数 u, v, w，表示景点 u 和景点 v 之间有一条长度为 w 的双向道路。

接下里的一行包含一个整数 Q，表示观景计划的数量。

接下来的 Q 行，每行包含两个整数 start, end，表示一个观景计划的起点和终点。

输出描述

对于每个观景计划，输出一行表示从起点到终点的最短路径长度。如果两个景点之间不存在路径，则输出 -1。

输入示例

输出示例

4
-1

提示信息

从 2 到 3 的路径长度为 4，3 到 4 之间并没有道路。

1 <= N, M, Q <= 1000.

思路分析

本题是经典的多源最短路问题。

在这之前我们讲解过，dijkstra朴素版、dijkstra堆优化、Bellman算法、Bellman队列优化（SPFA）都是单源最短路，即只能有一个起点。

而本题是多源最短路，即求多个起点到多个终点的多条最短路径。

通过本题，我们来系统讲解一个新的最短路算法-Floyd 算法。

Floyd 算法对边的权值正负没有要求，都可以处理。

Floyd算法核心思想是动态规划。

例如我们再求节点1 到节点9 的最短距离，用二维数组来表示即：grid[1][9]，如果最短距离是10 ，那就是 grid[1][9] = 10。

那节点1 到节点9 的最短距离是不是可以由节点1 到节点5的最短距离 + 节点5到节点9的最短距离组成呢？

即 grid[1][9] = grid[1][5] + grid[5][9]

节点1 到节点5的最短距离是不是可以有节点1 到节点3的最短距离 + 节点3 到节点5 的最短距离组成呢？

即 grid[1][5] = grid[1][3] + grid[3][5]

以此类推，节点1 到节点3的最短距离可以由更小的区间组成。

那么这样我们是不是就找到了，子问题推导求出整体最优方案的递归关系呢。

节点1 到节点9 的最短距离可以由节点1 到节点5的最短距离 + 节点5到节点9的最短距离组成，也可以有节点1 到节点7的最短距离 + 节点7 到节点9的最短距离的距离组成。

那么选哪个呢？

是不是要选一个最小的，毕竟是求最短路。

此时我们已经接近明确递归公式了。

之前在讲解动态规划的时候，给出过动规五部曲：

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

那么接下来我们还是用这五部来给大家讲解 Floyd。

1、确定dp数组（dp table）以及下标的含义

这里我们用 grid数组来存图，那就把dp数组命名为 grid。

grid[i][j][k] = m，表示节点i 到节点j 以[1...k] 集合为中间节点的最短距离为m。

可能有录友会想，凭什么就这么定义呢？

节点i 到节点j 的最短距离为m，这句话可以理解，但以[1...k]集合为中间节点就理解不辽了。

节点i 到节点j 的最短路径中一定是经过很多节点，那么这个集合用[1...k] 来表示。

你可以反过来想，节点i 到节点j 中间一定经过很多节点，那么你能用什么方式来表述中间这么多节点呢？

所以这里的k不能单独指某个节点，k 一定要表示一个集合，即[1...k] ，表示节点1 到节点k 一共k个节点的集合。

2、确定递推公式

在上面的分析中我们已经初步感受到了递推的关系。

我们分两种情况：

节点i 到节点j 的最短路径经过节点k
节点i 到节点j 的最短路径不经过节点k

对于第一种情况，grid[i][j][k] = grid[i][k][k - 1] + grid[k][j][k - 1]

节点i 到节点k 的最短距离是不经过节点k，中间节点集合为[1...k-1]，所以表示为grid[i][k][k - 1]

节点k 到节点j 的最短距离也是不经过节点k，中间节点集合为[1...k-1]，所以表示为 grid[k][j][k - 1]

第二种情况，grid[i][j][k] = grid[i][j][k - 1]

如果节点i 到节点j的最短距离不经过节点k，那么中间节点集合[1...k-1]，表示为 grid[i][j][k - 1]

因为我们是求最短路，对于这两种情况自然是取最小值。

即： grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1]， grid[i][j][k - 1])

3、dp数组如何初始化

grid[i][j][k] = m，表示节点i 到节点j 以[1...k] 集合为中间节点的最短距离为m。

刚开始初始化k 是不确定的。

例如题目中只是输入边（节点2 -> 节点6，权值为3），那么grid[2][6][k] = 3，k需要填什么呢？

把k 填成1，那如何上来就知道节点2 经过节点1 到达节点6的最短距离是多少呢。

所以只能把k 赋值为 0，本题节点0 是无意义的，节点是从1 到 n。

这样我们在下一轮计算的时候，就可以根据 grid[i][j][0] 来计算 grid[i][j][1]，此时的 grid[i][j][1] 就是节点i 经过节点1 到达节点j 的最小距离了。

grid数组是一个三维数组，那么我们初始化的数据在 i 与 j 构成的平层，如图：

红色的底部一层是我们初始化好的数据，注意：从三维角度去看初始化的数据很重要，下面我们在聊遍历顺序的时候还会再讲。

所以初始化代码：

vector<vector<vector<int>>> grid(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, 10005)));  // C++定义了一个三位数组，10005是因为边的最大距离是10^4

for(int i = 0; i < m; i++){
    cin >> p1 >> p2 >> val;
    grid[p1][p2][0] = val;
    grid[p2][p1][0] = val; // 注意这里是双向图
}

grid数组中其他元素数值应该初始化多少呢？

本题求的是最小值，所以输入数据没有涉及到的节点的情况都应该初始为一个最大数。

这样才不会影响，每次计算去最小值的时候初始值对计算结果的影响。

所以grid数组的定义可以是：

// C++写法，定义了一个三位数组，10005是因为边的最大距离是10^4
vector<vector<vector<int>>> grid(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, 10005)));

4、确定遍历顺序

从递推公式：grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1]， grid[i][j][k - 1]) 可以看出，我们需要三个for循环，分别遍历i，j 和k

而 k 依赖于 k - 1， i 和j 的到并不依赖与 i - 1 或者 j - 1 等等。

那么这三个for的嵌套顺序应该是什么样的呢？

我们来看初始化，我们是把 k =0 的 i 和j 对应的数值都初始化了，这样才能去计算 k = 1 的时候 i 和 j 对应的数值。

这就好比是一个三维坐标，i 和j 是平层，而k 是垂直向上的。

遍历的顺序是从底向上一层一层去遍历。

所以遍历k 的for循环一定是在最外面，这样才能一层一层去遍历。如图：

至于遍历 i 和 j 的话，for 循环的先后顺序无所谓。

代码如下：

for (int k = 1; k <= n; k++) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1]);
        }
    }
}

有录友可能想，难道遍历k 放在最里层就不行吗？

k 放在最里层，代码是这样：

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        for (int k = 1; k <= n; k++) {
            grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1]);
        }
    }
}

此时就遍历了 j 与 k 形成一个平面，i 则是纵面，那遍历就是这样的：

而我们初始化的数据是 k 为0， i 和 j 形成的平面做初始化，如果以 k 和 j 形成的平面去一层一层遍历，就造成了递推公式用不上上一轮计算的结果，从而导致结果不对（初始化的部分是 i 与j 形成的平面，在初始部分有讲过）。

我再给大家举一个测试用例

就是图：

求节点1 到节点 2 的最短距离，运行结果是 10 ，但正确的结果很明显是3。

为什么呢？

因为 k 放在最里面，先就把节点1 和节点 2 的最短距离就确定了，后面再也不会计算节点 1 和节点 2的距离，同时也不会基于初始化或者之前计算过的结果来计算，即：不会考虑节点1 到节点3，节点3 到节点 4，节点4到节点2 的距离。

造成这一原因，是在三维立体坐标中，我们初始化的是 i 和 i 在k 为0 所构成的平面，但遍历的时候是以 j 和 k构成的平面以 i 为垂直方向去层次遍历。

而遍历k 的for循环如果放在中间呢，同样是 j 与k 行程一个平面，i 是纵面，遍历的也是这样：

同样不能完全用上初始化和上一层计算的结果。

根据这个情况再举一个例子：

图：

求节点1 到节点3 的最短距离，如果k循环放中间，程序的运行结果是 -1，也就是不能到达节点3。

在计算 grid[i][j][k] 的时候，需要基于 grid[i][k][k-1] 和 grid[k][j][k-1]的数值。

也就是计算 grid[1][3][2] （表示节点1 到节点3，经过节点2）的时候，需要基于 grid[1][2][1] 和 grid[2][3][1]的数值，而我们初始化，只初始化了 k为0 的那一层。

造成这一原因依然是在三维立体坐标中，我们初始化的是 i 和 j 在k 为0 所构成的平面，但遍历的时候是以 j 和 k构成的平面以 i 为垂直方向去层次遍历。

很多录友对于 floyd算法的遍历顺序搞不懂，其实是没有从三维的角度去思考，同时我把三维立体图给大家画出来，遍历顺序标出来，大家就很容易想明白，为什么 k 放在最外层才能用上初始化和上一轮计算的结果了。

#基于三维数组的Floyd

if __name__ == '__main__':
    max_int = 10005  # 设置最大路径，因为边最大距离为10^4

    n, m = map(int, input().split())

    grid = [[[max_int] * (n+1) for _ in range(n+1)] for _ in range(n+1)]  # 初始化三维dp数组

    for _ in range(m):
        p1, p2, w = map(int, input().split())
        grid[p1][p2][0] = w
        grid[p2][p1][0] = w

    # 开始floyd
    for k in range(1, n+1):
        for i in range(1, n+1):
            for j in range(1, n+1):
                grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1])

    # 输出结果
    z = int(input())
    for _ in range(z):
        start, end = map(int, input().split())
        if grid[start][end][n] == max_int:
            print(-1)
        else:
            print(grid[start][end][n])
#基于二维数组的Floyd

if __name__ == '__main__':
    max_int = 10005  # 设置最大路径，因为边最大距离为10^4

    n, m = map(int, input().split())

    grid = [[max_int]*(n+1) for _ in range(n+1)]  # 初始化二维dp数组

    for _ in range(m):
        p1, p2, val = map(int, input().split())
        grid[p1][p2] = val
        grid[p2][p1] = val

    # 开始floyd
    for k in range(1, n+1):
        for i in range(1, n+1):
            for j in range(1, n+1):
                grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j])

    # 输出结果
    z = int(input())
    for _ in range(z):
        start, end = map(int, input().split())
        if grid[start][end] == max_int:
            print(-1)
        else:
            print(grid[start][end])

二、骑士的攻击（A * 算法精讲（A star算法））

题目描述

在象棋中，马和象的移动规则分别是“马走日”和“象走田”。现给定骑士的起始坐标和目标坐标，要求根据骑士的移动规则，计算从起点到达目标点所需的最短步数。

棋盘大小 1000 x 1000（棋盘的 x 和 y 坐标均在 [1, 1000] 区间内，包含边界）

输入描述

第一行包含一个整数 n，表示测试用例的数量，1 <= n <= 100。

接下来的 n 行，每行包含四个整数 a1, a2, b1, b2，分别表示骑士的起始位置 (a1, a2) 和目标位置 (b1, b2)。

输出描述

输出共 n 行，每行输出一个整数，表示骑士从起点到目标点的最短路径长度。

输入示例

输出示例

提示信息

骑士移动规则如图，红色是起始位置，黄色是骑士可以走的地方。

思路

我们看到这道题目的第一个想法就是广搜，这也是最经典的广搜类型题目。

提交后，大家会发现，超时了。

因为本题地图足够大，且 n 也有可能很大，导致有非常多的查询。

我们来看一下广搜的搜索过程，如图，红色是起点，绿色是终点，黄色是要遍历的点，最后从起点找到达到终点的最短路径是棕色。

可以看出广搜中，做了很多无用的遍历，黄色的格子是广搜遍历到的点。

这里我们能不能让便利方向，向这终点的方向去遍历呢？

这样我们就可以避免很多无用遍历。

#Astar

Astar 是一种广搜的改良版。有的是 Astar是 dijkstra 的改良版。

其实只是场景不同而已我们在搜索最短路的时候，如果是无权图（边的权值都是1）那就用广搜，代码简洁，时间效率和 dijkstra 差不多（具体要取决于图的稠密）

如果是有权图（边有不同的权值），优先考虑 dijkstra。

而 Astar 关键在于启发式函数，也就是影响广搜或者 dijkstra 从容器（队列）里取元素的优先顺序。

以下，我用BFS版本的A * 来进行讲解。

在BFS中，我们想搜索，从起点到终点的最短路径，要一层一层去遍历。

如果使用A * 的话，其搜索过程是这样的，如图，图中着色的都是我们要遍历的点。

（上面两图中最短路长度都是8，只是走的方式不同而已）

大家可以发现 BFS 是没有目的性的一圈一圈去搜索，而 A * 是有方向性的去搜索。

看出 A * 可以节省很多没有必要的遍历步骤。

为了让大家可以明显看到区别，我将 BFS 和 A * 制作成可视化动图，大家可以自己看看动图，效果更好。

地址：https://kamacoder.com/tools/knight.html

那么 A * 为什么可以有方向性的去搜索，它的如何知道方向呢？

其关键在于启发式函数。

那么启发式函数落实到代码处，如果指引搜索的方向？

在本篇开篇中给出了BFS代码，指引搜索的方向的关键代码在这里：

int m=q.front();q.pop();
int n=q.front();q.pop();

从队列里取出什么元素，接下来就是从哪里开始搜索。

所以启发式函数要影响的就是队列里元素的排序！

这是影响BFS搜索方向的关键。

对队列里节点进行排序，就需要给每一个节点权值，如何计算权值呢？

每个节点的权值为F，给出公式为：F = G + H

G：起点达到目前遍历节点的距离

F：目前遍历的节点到达终点的距离

起点达到目前遍历节点的距离 + 目前遍历的节点到达终点的距离就是起点到达终点的距离。

本题的图是无权网格状，在计算两点距离通常有如下三种计算方式：

曼哈顿距离，计算方式： d = abs(x1-x2)+abs(y1-y2)
欧氏距离（欧拉距离），计算方式：d = sqrt( (x1-x2)^2 + (y1-y2)^2 )
切比雪夫距离，计算方式：d = max(abs(x1 - x2), abs(y1 - y2))

x1, x2 为起点坐标，y1, y2 为终点坐标，abs 为求绝对值，sqrt 为求开根号，

选择哪一种距离计算方式也会导致 A * 算法的结果不同。

本题，采用欧拉距离才能最大程度体现点与点之间的距离。

所以使用欧拉距离计算和广搜搜出来的最短路的节点数是一样的。（路径可能不同，但路径上的节点数是相同的）

我在制作动画演示的过程中，分别给出了曼哈顿、欧拉以及契比雪夫三种计算方式下，A * 算法的寻路过程，大家可以自己看看看其区别。

动画地址：https://kamacoder.com/tools/knight.html

计算出来 F 之后，按照 F 的大小，来选去出队列的节点。

可以使用优先级队列帮我们排好序，每次出队列，就是F最小的节点。

import heapq
import sys

directions = [(-2, 1), (-2, -1), (-1, 2), (-1, -2), (1, 2), (1, -2), (2, 1), (2, -1)]

class Node:
    def __init__(self, x, y, g, h):
        self.x = x
        self.y = y
        self.g = g
        self.h = h
        self.f = g + h
    
    def __lt__(self, other):
        return self.f < other.f

def heuristic(x1, y1, x2, y2):
    return (x1 - x2) ** 2 + (y1 - y2) ** 2

def astar(start_x, start_y, end_x, end_y):
    dp = [[0] * 1001 for _ in range(1001)]
    pq = []
    heapq.heappush(pq, Node(start_x, start_y, 0, heuristic(start_x, start_y, end_x, end_y)))
    dp[start_x][start_y] = 1
    
    while pq:
        cur = heapq.heappop(pq)
        if cur.x == end_x and cur.y == end_y:
            return dp[end_x][end_y] - 1
        
        for dx, dy in directions:
            next_x = cur.x + dx
            next_y = cur.y + dy
            
            if 1 <= next_x <= 1000 and 1 <= next_y <= 1000 and dp[next_x][next_y] == 0:
                dp[next_x][next_y] = dp[cur.x][cur.y] + 1
                heapq.heappush(pq, Node(next_x, next_y, cur.g + 5, heuristic(next_x, next_y, end_x, end_y)))
    
    return -1  # if the destination cannot be reached

def main():
    input = sys.stdin.read
    data = list(map(int, input().split()))
    
    index = 0
    n = data[index]
    index += 1
    
    results = []
    
    for _ in range(n):
        a1 = data[index]
        a2 = data[index + 1]
        b1 = data[index + 2]
        b2 = data[index + 3]
        index += 4
        
        result = astar(a1, a2, b1, b2)
        results.append(result)
    
    for result in results:
        print(result)

if __name__ == "__main__":
    main()

三、最短路算法总结

至此已经讲解了四大最短路算法，分别是Dijkstra、Bellman_ford、SPFA 和 Floyd。

针对这四大最短路算法，我用了七篇长文才彻底讲清楚，分别是：

dijkstra朴素版
dijkstra堆优化版
Bellman_ford
Bellman_ford 队列优化算法（又名SPFA）
bellman_ford 算法判断负权回路
bellman_ford之单源有限最短路
Floyd 算法精讲
启发式搜索：A * 算法

最短路算法比较复杂，而且各自有各自的应用场景，我来用一张表把讲过的最短路算法的使用场景都展现出来：

（因为A * 属于启发式搜索，和上面最短路算法并不是一类，不适合一起对比，所以没有放在一起）

可能有同学感觉：这个表太复杂了，我记也记不住。

其实记不住的原因还是对这几个最短路算法没有深刻的理解。

这里我给大家一个大体使用场景的分析：

如果遇到单源且边为正数，直接Dijkstra。

至于 使用朴素版还是堆优化版还是取决于图的稠密度，多少节点多少边算是稠密图，多少算是稀疏图，这个没有量化，如果想量化只能写出两个版本然后做实验去测试，不同的判题机得出的结果还不太一样。

一般情况下，可以直接用堆优化版本。

如果遇到单源边可为负数，直接 Bellman-Ford，同样 SPFA 还是 Bellman-Ford 取决于图的稠密度。

一般情况下，直接用 SPFA。

如果有负权回路，优先 Bellman-Ford，如果是有限节点最短路也优先 Bellman-Ford，理由是写代码比较方便。

如果是遇到多源点求最短路，直接 Floyd。

除非源点特别少，且边都是正数，那可以多次 Dijkstra 求出最短路径，但这种情况很少，一般出现多个源点了，就是想让你用 Floyd 了。

对于A * ，由于其高效性，所以在实际工程应用中使用最为广泛，由于其结果的不唯一性，也就是可能是次短路的特性，一般不适合作为算法题。

游戏开发、地图导航、数据包路由等都广泛使用 A * 算法。

四、图论总结

从深搜广搜到并查集，从最小生成树到拓扑排序，最后是最短路算法系列。

至此算上本篇，一共30篇文章，图论之旅就在此收官了。

在0098.所有可达路径，我们接触了两种图的存储方式，邻接表和邻接矩阵，掌握两种图的存储方式很重要。

图的存储方式也是大家习惯在核心代码模式下刷题经常忽略的知识点。因为在力扣上刷题不需要掌握图的存储方式。

#深搜与广搜

在二叉树章节中，其实我们讲过了深搜和广搜在二叉树上的搜索过程。

在图论章节中，深搜与广搜就是在图这个数据结构上的搜索过程。

深搜与广搜是图论里基本的搜索方法，大家需要掌握三点：

搜索方式：深搜是可一个方向搜，不到黄河不回头。广搜是围绕这起点一圈一圈的去搜。
代码模板：需要熟练掌握深搜和广搜的基本写法。
应用场景：图论题目基本上可以即用深搜也可用广搜，无疑是用哪个方便而已

#注意事项

需要注意的是，同样是深搜模板题，会有两种写法。

在0099.岛屿的数量深搜.md 和 0105.有向图的完全可达性，涉及到dfs的两种写法。

我们对dfs函数的定义是是处理当前节点还是处理下一个节点很重要，决定了两种dfs的写法。

这也是为什么很多录友看到不同的dfs写法，结果发现提交都能过的原因。

而深搜还有细节，有的深搜题目需要用到回溯的过程，有的就不用回溯的过程，

一般是需要计算路径的问题需要回溯，如果只是染色问题（岛屿问题系列）就不需要回溯。

例如： 0105.有向图的完全可达性深搜就不需要回溯，而 0098.所有可达路径中的递归就需要回溯，文章中都有详细讲解

注意：以上说的是不需要回溯，不是没有回溯，只要有递归就会有回溯，只是我们是否需要用到回溯这个过程，这是需要考虑的。

很多录友写出来的广搜可能超时了，例如题目：0099.岛屿的数量广搜

根本原因是只要加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再去标记走过。

具体原因，我在0099.岛屿的数量广搜中详细讲了。

在深搜与广搜的讲解中，为了防止惯性思维，我特别加入了题目 0106.岛屿的周长，提醒大家，看到类似的题目，也不要上来就想着深搜和广搜。

还有一些图的问题，在题目描述中，是没有图的，需要我们自己构建一个图，例如 0110.字符串接龙，题目中连线都没有，需要我们自己去思考什么样的两个字符串可以连成线。

#并查集

并查集相对来说是比较复杂的数据结构，其实他的代码不长，但想彻底学透并查集，需要从多个维度入手，

我在理论基础篇的时候讲解如下重点：

为什么要用并查集，怎么不用个二维数据，或者set、map之类的。
并查集能解决那些问题，哪些场景会用到并查集
并查集原理以及代码实现
并查集写法的常见误区
带大家去模拟一遍并查集的过程
路径压缩的过程
时间复杂度分析

上面这几个维度大家都去思考了，并查集基本就学明白了。

其实理论基础篇就算是给大家出了一道裸的并查集题目了，所以在后面的题目安排中，会稍稍的拔高一些，重点在于并查集的应用上。

例如并查集可以判断这个图是否是树，因为树的话，只有一个根，符合并查集判断集合的逻辑，题目：0108.冗余连接。

在0109.冗余连接II 中对有向树的判断难度更大一些，需要考虑的情况比较多。

#最小生成树

最小生成树是所有节点的最小连通子图，即：以最小的成本（边的权值）将图中所有节点链接到一起。

最小生成树算法，有prim 和 kruskal。

prim 算法是维护节点的集合，而 Kruskal 是维护边的集合。

在稀疏图中，用Kruskal更优。在稠密图中，用prim算法更优。

边数量较少为稀疏图，接近或等于完全图（所有节点皆相连）为稠密图

Prim 算法时间复杂度为 O(n^2)，其中 n 为节点数量，它的运行效率和图中边树无关，适用稠密图。

Kruskal算法时间复杂度为 O(nlogn)，其中n 为边的数量，适用稀疏图。

关于 prim算法，我自创了三部曲，来帮助大家理解：

第一步，选距离生成树最近节点
第二步，最近节点加入生成树
第三步，更新非生成树节点到生成树的距离（即更新minDist数组）

大家只要理解这三部曲， prim算法至少是可以写出一个框架出来，然后在慢慢补充细节，这样不至于自己在写prim的时候两眼一抹黑完全凭感觉去写。

minDist数组是prim算法的灵魂，它帮助 prim算法完成最重要的一步，就是如何找到距离最小生成树最近的点。

kruscal的主要思路：

边的权值排序，因为要优先选最小的边加入到生成树里
遍历排序后的边
- 如果边首尾的两个节点在同一个集合，说明如果连上这条边图中会出现环
- 如果边首尾的两个节点不在同一个集合，加入到最小生成树，并把两个节点加入同一个集合

而判断节点是否在一个集合以及将两个节点放入同一个集合，正是并查集的擅长所在。

所以 Kruskal 是需要用到并查集的。

这也是我在代码随想录图论编排上为什么要先讲解并查集在讲解最小生成树。

#拓扑排序

拓扑排序是在图上的一种排序。

概括来说，给出一个有向图，把这个有向图转成线性的排序就叫拓扑排序。

同样，拓扑排序也可以检测这个有向图是否有环，即存在循环依赖的情况。

拓扑排序的一些应用场景，例如：大学排课，文件下载依赖等等。

只要记住如下两步拓扑排序的过程，代码就容易写了：

找到入度为0 的节点，加入结果集
将该节点从图中移除

#最短路算法

最短路算法是图论中，比较复杂的算法，而且不同的最短路算法都有不同的应用场景。

我在最短路算法总结篇里已经做了一个高度的概括。

大家要时常温故而知新，才能透彻理解各个最短路算法

LookCodes

关注

22
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

算法工程师第五十三天（Floyd 算法精讲 A * 算法精讲 （A star算法）最短路算法总结 图论总结 ）

题目描述

输入描述

输出描述

输入示例

输出示例

提示信息

题目描述

输入描述

输出描述

输入示例

输出示例

提示信息

思路

#Astar

#深搜与广搜

#注意事项

#并查集

#最小生成树

#拓扑排序

#最短路算法

算法工程师第五十三天（Floyd 算法精讲 A * 算法精讲（A star算法）最短路算法总结图论总结）