代码随想录算法训练营第七十二天 | Floyd算法精讲，A*算法精讲，最短路算法总结篇，图论总结篇-优快云博客

本文链接：https://blog.youkuaiyun.com/Triple_3/article/details/145025947

Floyd算法精讲

题目讲解：代码随想录
重点：

理解Floyd算法本质为动态规划，其中理解遍历顺序最为重要。

思路：

dp数组的含义
节点i到节点j以[1…k]集合中的一个节点为中间节点的最短距离为graph[i][j][k]
int[][][] graph = new int[n + 1][n + 1][n + 1];
for (int i = 1; i <= n; i++) {
   for (int j = 1; j <= n; j++) Arrays.fill(graph[i][j], MAX_VAL);
}
递推公式
求最短路取最小值: 两种情况, 经过k或不经过k
graph[i][j][k] = Math.min(graph[i][j][k - 1], graph[i][k][k - 1] + graph[k][j][k - 1]);
dp数组初始化
递推公式是从k-1推来, 也就是三维中的底下一层往顶上一层推, 所以初始化k=0的时候
for (int i = 0; i < m; i++) {
   int u = scanner.nextInt();
   int v = scanner.nextInt();
   int w = scanner.nextInt();
   graph[u][v][0] = w;
   graph[v][u][0] = w;
}
遍历顺序
递推公式是从k-1推来, 也就是三维中的底下一层往顶上一层推, 所以最外层循环为k, 里面i和j无所谓
for (int k = 1; k <= n; k++)
   for (int i = 1; i <= n; i++)
       for (int j = 1; j <= n; j++)

// 1. dp数组的含义
// 2. 递推公式
// 3. dp数组初始化
// 4. 遍历顺序
public class WalkAroundPark {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        // 不选用Integer.MAX_VALUE是为了避免相加导致数值溢出
        int MAX_VAL = 10005;
        // 1. dp数组的含义
        // 节点i到节点j以[1...k]集合中的一个节点为中间节点的最短距离为graph[i][j][k]
        int[][][] graph = new int[n + 1][n + 1][n + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                Arrays.fill(graph[i][j], MAX_VAL);
            }
        }
        // 3. dp数组初始化
        // 递推公式是从k-1推来, 也就是三维中的底下一层往顶上一层推, 所以初始化k=0的时候
        for (int i = 0; i < m; i++) {
            int u = scanner.nextInt();
            int v = scanner.nextInt();
            int w = scanner.nextInt();
            graph[u][v][0] = w;
            graph[v][u][0] = w;
        }
        // 4. 遍历顺序
        // 递推公式是从k-1推来, 也就是三维中的底下一层往顶上一层推, 所以最外层循环为k, 里面i和j无所谓
        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    // 2. 递推公式
                    // 求最短路取最小值: 两种情况, 经过k或不经过k
                    graph[i][j][k] = Math.min(graph[i][j][k - 1], graph[i][k][k - 1] + graph[k][j][k - 1]);
                }
            }
        }
        int q = scanner.nextInt();
        while (q > 0) {
            int start = scanner.nextInt();
            int end = scanner.nextInt();
            if (graph[start][end][n] == MAX_VAL) System.out.println(-1);
            else System.out.println(graph[start][end][n]);
            q--;
        }
    }
}

A*算法精讲

题目讲解：代码随想录
重点：

A*算法利用最小堆排序启发函数以减少BFS需要探索的节点数量。

思路：

实现Knight类及自然排序

class Knight implements Comparable<Knight> {
   int x, y, g, h, f;
   // PriorityQueue中自然排序, 从小到大
   @Override
   public int compareTo(Knight o) {
       return Integer.compare(f, o.f);
   }
}

初始化start及它的启发式信息，然后推入最小堆

Knight start = new Knight();
start.x = a1;
start.y = a2;
// 起点达到目前遍历节点的距离
start.g = 0;
// 目前遍历的节点到达终点的距离
start.h = (start.x - b1) * (start.x - b1) + (start.y - b2) * (start.y - b2);
// 每个节点的权值
start.f = start.g + start.h;
priorityQueue.offer(start);

进行A*的BFS探索，总共8个方向，如果没探索过就推入最小堆

while (!priorityQueue.isEmpty()) {
   Knight cur = priorityQueue.poll();
   if (cur.x == b1 && cur.y == b2) break;
   for (int i = 0; i < 8; i++) {
       Knight next = new Knight();
       next.x = cur.x + dir[i][0];
       next.y = cur.y + dir[i][1];
       // 检查是否超出格子界限
       if(next.x < 1 || next.x > 1000 || next.y < 1 || next.y > 1000) continue;
       // 检查是否已经探索过, 没探索过的才需要接着探索, 已经探索过说明不是最短路径了
       if (moves[next.x][next.y] == 0) {
           moves[next.x][next.y] = moves[cur.x][cur.y] + 1;
           next.g = cur.g + 5;
           next.h = (next.x - b1) * (next.x - b1) + (next.y - b2) * (next.y - b2);
           next.f = next.g + next.h;
           priorityQueue.offer(next);
       }
   }
}

class Knight implements Comparable<Knight> {
    int x, y, g, h, f;
    // PriorityQueue中自然排序, 从小到大
    @Override
    public int compareTo(Knight o) {
        return Integer.compare(f, o.f);
    }
}
public class KnightlyAttack {
    // 8个方向
    static int[][] dir = {{-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        // 最小堆的优先队列
        PriorityQueue<Knight> priorityQueue = new PriorityQueue<>();
        while (n > 0) {
            int a1 = scanner.nextInt();
            int a2 = scanner.nextInt();
            int b1 = scanner.nextInt();
            int b2 = scanner.nextInt();
            // 记录移动到当前格子一共走了多少步
            int[][] moves = new int[1001][1001];
            Knight start = new Knight();
            start.x = a1;
            start.y = a2;
            // 起点达到目前遍历节点的距离
            start.g = 0;
            // 目前遍历的节点到达终点的距离
            start.h = (start.x - b1) * (start.x - b1) + (start.y - b2) * (start.y - b2);
            // 每个节点的权值
            start.f = start.g + start.h;
            priorityQueue.offer(start);
            while (!priorityQueue.isEmpty()) {
                Knight cur = priorityQueue.poll();
                if (cur.x == b1 && cur.y == b2) break;
                for (int i = 0; i < 8; i++) {
                    Knight next = new Knight();
                    next.x = cur.x + dir[i][0];
                    next.y = cur.y + dir[i][1];
                    // 检查是否超出格子界限
                    if(next.x < 1 || next.x > 1000 || next.y < 1 || next.y > 1000) continue;
                    // 检查是否已经探索过, 没探索过的才需要接着探索, 已经探索过说明不是最短路径了
                    if (moves[next.x][next.y] == 0) {
                        moves[next.x][next.y] = moves[cur.x][cur.y] + 1;
                        next.g = cur.g + 5;
                        next.h = (next.x - b1) * (next.x - b1) + (next.y - b2) * (next.y - b2);
                        next.f = next.g + next.h;
                        priorityQueue.offer(next);
                    }
                }
            }
            // 上一个循环找到目标节点后直接break了, 需要在这里清空队列
            while (!priorityQueue.isEmpty()) priorityQueue.poll();
            System.out.println(moves[b1][b2]);
            n--;
        }
    }
}

最短路算法总结篇

总结讲解：代码随想录

如果遇到单源且边为正数，直接Dijkstra。使用朴素版还是堆优化版还是取决于图的稠密度。一般情况下，可以直接用堆优化版本。
如果遇到单源边可为负数，直接 Bellman-Ford。一般情况下，直接用 SPFA。
如果有负权回路，优先 Bellman-Ford。
如果有限节点最短路，优先 Bellman-Ford。
如果是遇到多源点求最短路，直接 Floyd。

图论总结篇

总结讲解：代码随想录

图的存储方式

邻接矩阵：二维数组
邻接表：列表嵌套链表

深搜与广搜

深搜是可一个方向搜，不到黄河不回头。广搜是围绕这起点一圈一圈的去搜。

深搜

对dfs函数的定义是是处理当前节点还是处理下一个节点很重要，决定了两种dfs的写法。
需要计算路径的问题需要回溯，如果只是染色问题（岛屿问题系列）就不需要回溯。

广搜

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

并查集

init
find
join
isSame

最小生成树

以最小的成本（边的权值）将图中所有节点链接到一起。
prim 算法是维护节点的集合，而 Kruskal 是维护边的集合。在稀疏图中，用Kruskal更优。在稠密图中，用prim算法更优。

Prim算法

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

Kruskal算法

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

拓扑排序

给出一个有向图，把这个有向图转成线性的排序就叫拓扑排序。
拓扑排序也可以检测这个有向图是否有环，即存在循环依赖的情况。

过程

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

最短路算法

Dijkstra：每次取距离源点最近的节点
Dijkstra Heap：用最小堆来快速获取距离源点最近的节点
Bellman ford：每次对所有边都进行松弛
SPFA：用队列保存需要松弛的直接相连的边
Floyd：动态规划所有点到不同点的最短距离
A*：让BFS或DFS有启发函数来选择点，而不是胡乱选择。