【Acwing算法基础课 第三章 搜索与图论（二）】最短路（java版详细注解！！你疑惑的点可能都写到了）题号 849~854

第三章 搜索与图论（二）

Dijkstra

849.Dijkstra求最短路I（*）

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 1号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式：输出一个整数，表示 1 号点到 n 号点的最短距离。如果路径不存在，则输出 −1。

数据范围：1≤n≤500,1≤m≤10^5,图中涉及边长均不超过10000。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

思路分析

如图，假设 S 是当前已经确定最短距离的点的集合。根据n、m的值可以确定是稠密图，用邻接矩阵来存储。本题核心代码就是 Dijkstra 方法。步骤简单阐述如下：（关于迪杰斯特拉算法可以去看王道书P225）核心思想就是：每一轮从 S 集合外即未确定最短路径的点中找一个最短路径最小的加入 S，然后再利用这个点更新其他点的最短路径（但不一定是其他点最终的最短路径）。

1. 如图所示，初始化 用来存储某点的最短路径的值的数组 dist；
2. 大循环 i ，表示轮次。每一轮都会找到一个加入集合 S 的点 t，也就是确定一个点的最短路径；
3. 每一轮都会遍历所有点 j，找到不在集合S中，即待确定最短路径的点中最短路径最小的点，作为此轮要加入集合 s 的点 t；
4. 将 t 的状态置为 true表示找到他的最短路径了；
5. 然后利用 t 去更新其他点的最短路径；
6. 大循环结束，每个点的最短路径都得求。

代码实现

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Arrays;

public class _849 {
    static int N = 510;
    static int n,m;  //输入的图的点数和边数
    static int g[][] = new int[N][N];  //用邻接矩阵存储图
    static int dist[] = new int[N];  //存储某点的最短路径的值
    static boolean st[] = new boolean[N];  //标记是否已经确定到 某个点的最短路径

    public static int dijkstra(){
        Arrays.fill(dist,0x3f3f3f);   //初始化将最短路设为无穷大
        dist[1] = 0;

        for (int i = 0; i < n; i++) {   //表示轮次，每一轮都会确定一个点的最短路径
            int t = -1;   ///t是本轮要找到的 s集合外最短路径最小的点（这个初始化值结合下面的判断条件理解）
            //遍历所有未确定最短路径的点，找到当前最短路径最小的点，作为此轮加入集合s的点
            for (int j = 1; j <= n; j++)
                if (!st[j] && (t == -1 || dist[t]>dist[j]))
                    //判断条件解释：这个t首先要变成 s集合外的一点，之后再根据距离大小不断更新成那个最小的点
                    // 达到前者的条件就是t为初始值并且找到S集合外一点的时候
                    // 但是t不能初始化成随便一个点，因为不知道这个点在S里还是S外，因此初始化为-1或0（这个用法可以借鉴到别处）
                    t=j;   //不断更新候选点

            st[t] = true;   //标记 t 点找到最短路径
            for (int j = 1; j <= n; j++)   //利用刚刚新确定的最短路径的点 更新其他点的最短路径
                dist[j] = Math.min(dist[j],dist[t]+g[t][j]);
        }

        if (dist[n] == 0x3f3f3f)   //如果到n点的不存在最短路径
            return -1;
        return dist[n];
    }

    public static void main(String[] args) throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s[] = bf.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);

        for (int i = 1; i <= n; i++)
            Arrays.fill(g[i], 0x3f3f3f);

        for (int i = 0; i < m; i++) {
            String s2[] = bf.readLine().split(" ");
            int a = Integer.parseInt(s2[0]);
            int b = Integer.parseInt(s2[1]);
            int c = Integer.parseInt(s2[2]);
            g[a][b] =Math.min(g[a][b],c);
        }
        System.out.println(dijkstra());
    }
}

850.Dijkstra求最短路II

和前一题的区别仅在于数据范围：1≤n,m≤1.5×10^5。并且如果最短路存在，则最短路的长度不超过 10^9。那么这个稀疏图再用两个for循环就会爆，需要优化一下算法。

思路分析

观察上述时间复杂度最高的一步，应该是1.1.1的第3步：每次寻找S集合外 dist 最小的点 t 都需要遍历整个 dist，这个 for 循环嵌套在轮数循环里就增加了很多时间复杂度。容易想到，用 堆 来寻找最小值，时间复杂度较小。这里用 java 的优先队列实现堆（具体原因和用法去看数据结构堆的那节）

有重边也不要紧，假设1->2有权重为2和3的边，再遍历到点1的时候2号点的距离会更新两次放入堆中。这样堆中会有很多冗余的点，但是在弹出的时候还是会弹出最小值2+x（x为之前确定的最短路径），并标记st为true，所以下一次弹出3+x会continue不会向下执行。

代码实现

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;

public class _850 {
    static int N = 1000010;
    static int n,m;  //输入的图的点数和边数
    static boolean st[] = new boolean[N];  //标记是否已经确定到 某个点的最短路径
    static int h[] = new int[N];
    static int e[] = new int[N];
    static int ne[] = new int[N];
    static int w[] = new int[N];   //存储边权
    static int idx;
    static int dist[] = new int[N];  //存储某点到编号为1的点的最短路径的值
    //优先队列的参数是int数组，因为堆的每个元素包括：编号和暂时最短距离；匿名函数表示：是最短路径的小根堆
    static PriorityQueue<int[]> heap = new PriorityQueue<>((a,b)->{return a[1] - b[1];});
    //邻接表添加新边的方法
    public static void add(int a,int b, int c){
        e[idx] = b;
        w[idx] = c;   //记录边权
        ne[idx] = h[a];
        h[a] = idx++;
    }

    public static int dijkstra(){
        Arrays.fill(dist,0x3f3f3f3f);   //初始化将最短路设为无穷大（少一个3f就会有测试点不过）
        dist[1] = 0;   //编号为 1 的点的最短路径是0
        heap.offer(new int[]{1, 0});  //将编号为1，最短距离为0的节点进堆
        while(heap.size() != 0){
            int[] a = heap.poll();   //取出堆顶元素
            int t = a[0], distance = a[1];   //t为元素编号，distance为该元素的最短距离
            if(st[t])   //如果这个元素已经被确定最短距离了（已经在集合 S 中）就直接退出本轮循环（为了防止输入重边的情况）
                continue;
            st[t] = true;
            //遍历该元素所有出边指向的点，看能不能更新这些点的最短距离
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] > distance + w[i]){
                    dist[j] = distance + w[i];
                    heap.offer(new int[]{j, dist[j]});  //把更新后的暂时最短路径加入堆中
                }
            }
        }
        if (dist[n] == 0x3f3f3f3f)   //如果到n点的不存在最短路径
            return -1;
        return dist[n];
    }

    public static void main(String[] args) throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s[] = bf.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        Arrays.fill(h, -1);

        for (int i = 0; i < m; i++) {
            String s2[] = bf.readLine().split(" ");
            int a = Integer.parseInt(s2[0]);
            int b = Integer.parseInt(s2[1]);
            int c = Integer.parseInt(s2[2]);
            add(a,b,c);
        }
        System.out.println(dijkstra());
    }
}

可能会疑惑 continue的作用，以为一个点不会反复进堆，因为一旦距离确定就不可能再更新距离。实际上，我们来看代码，for循环会把所有满足dist[j] > distance + w[i] 的点都加入堆，有的点比如 c 它既是 a 的邻接点又是 b的邻接点，这样的点可能会在将 a 的邻接点更新的时候加进去一次，又在更新 b 的邻接点的时候又加进去一次，这样队列中就有两个编号一样、距离不同的点。因此一个点可能同时以不同距离的状态多次进堆。但实际上 dist[c]在被第一个点更新完后就确定了，因为我们 Dijkstra 是每次取出一个全局最小的dist来更新别的点，每个点的最短距离一定是递增的，不可能出现后面进入集合 S 的点还会更新出 更短的 邻接点的最短路径，所以我们第一次就直接可以把 st 置为true，后面再碰到直接跳过啦！

bellman-ford

853.有边权限制的最短路（代码简单但是要理解透彻还是有点难）

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。注意：图中可能 存在负权回路。

输入格式：第一行包含三个整数 n,m,k。接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。点的编号为 1∼n。

输出格式：输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。如果不存在满足条件的路径，则输出 impossible。

数据范围：1≤n,k≤500, 1≤m≤10000, 1≤x,y≤n，任意边长的绝对值不超过 10000。

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

输出样例：

3

思路分析

不存在最短路径的情况

因为存在负权回路，如图，2->3就没有最短路径

算法选择分析

边权是负数就说明不能使用 Dijkstra 算法。Dijkstra算法的3个步骤：1、找到当前未标识的且离源点最近的点t；2、对t号点点进行标识；3、用t号点更新其他点的距离。例子：

1. 初始dist[1] = 0

2. 找到了未标识且离源点1最近的结点1，标记1号点，用1号点更新其他所有点的距离，2号点被更新成dist[2] = 2，3号点被更新成dist[3] = 5

3. 找到了未标识且离源点1最近的结点2，标识2号点，用2号点更新其他所有点的距离，4号点被更新成dist[4] = 4

4. 找到了未标识且离源点1最近的结点4，标识4号点，用4号点更新其他所有点的距离，5号点被更新成dist[5] = 5

5. 找到了未标识且离源点1最近的结点3，标识3号点，用3号点更新其他所有点的距离，4号点被更新成dist[4] = 3

6. 结束

7. 得到1号点到5号点的最短距离是5，对应的路径是1 -> 2 -> 4 -> 5，并不是真正的最短距离

简单来说，有负权边不能使用 Dijkstra 算法的原因就是：每个点第一次被确定后st[j] = true，dist[j]就是最短距离了，之后就不能再被更新了（一锤子买卖），而如果有负权边的话，那已经确定的点的dist[j]不一定是最短了。

“松弛”

以某一顶点 为中心进行扩展，例如该顶点的出边有 2 -> 3 和 2 -> 4 这两条边，我们逐一比较看看能不能使 顶点1 到 顶点3 或者顶点4 的距离变短，这个进程的专业术语叫做 “松弛” 。

bellman- ford算法

之后满足

外循环的作用

对所有边进行松弛操作的次数（第 i 次的意义：边数为 i 条的最短路径）

那又是为什么呢？（这个想了很久，因为所有文章都是解释到上面就没接着解释了）如图：

我们模拟一下可以发现，第一次循环时，对所有边松弛之后只有编号 1 的邻节点2、5的 dist 发生更新， 因为初始除了 1 其他结点的 dist 都是 +∞，

1. 对于 1 的邻节点 2、5：

​ 从+∞ 更新成 w （无论 w正负一定比 +∞ 小）

2. 对于除 1 的邻节点即除 2、5之外的点：

​ 对于正权边，如2-3、3-4等，一定不会更新 dist 值，因为相当于在 +∞上继续+，肯定更大；

​ 对于负权边，（假设图上有），只更新成 +∞ - w，如果最短路存在的情况下，一定不是最终的 dist

因此第一次循环只有迈一步的点（2、5）松弛成功。

第二次循环，在第一次循环时松弛成功的 2、5两个点的基础上继续松弛。同理，只有迈两步的点会松弛成功。以此类推，循环k次就表示迈 k 步的点松弛成功，也就是路径更新完成，也就是从 1 号点到 n 号点的最多经过 k 条边的最短距离。

数组备份

这里的 dist[a] 在实际算法中要改成 back[a] ，即在第二层循环内：

dist[b] = min(dist[b], backup[a] + w);

原因：避免串联。

串联是什么？

先举个栗子。如图，在边数限制为 1 的情况下，节点3的距离应该是3，但是由于串联情况，利用本轮更新的节点2更新了节点3的距离，所以现在节点3的距离是2。

正确做法是用上轮节点2更新的距离——无穷大，来更新节点3， 再取最小值，所以节点3离起点的距离是3。

刚才解释了外循环的意义，也就是说，在同一轮外循环里，允许的最长路径条数（如图是1）是一样的，如果先更新了2号点，再用2号点更新了3号点，那3 允许的最长路径条数就不对了，这样就发生了“串联”。

怎么保证不发生串联呢？

我们保证更新的时候只用上一次循环的结果就行。因为上一轮循环允许的最长路径条数会小1，这一轮+1刚好满足不超出允许的最长路径条数。所以我们先备份一下。备份之后backup数组存的就是上一次循环的结果，我们用上一次循环的结果来更新距离。其实和 dp 背包问题滚动数组那一题有点像，就是同一轮循环更新别的点的时候，需要用到的数据不能“太新了”，得用上一轮的旧数据。比如我这一轮会更新b点，然而 b 点的更新会用到 a 点， 但是 a 点本轮也会更新并且在 b 之前就更新，等到了 b 的时候 a “太新了”，这样就会出错。在今后在考虑其他问题的时候也要注意到这点。

代码实现

上面思路了解清楚后代码就比较简单了。别的细节已经写在注释里。注意，c的结构体在java中都可以用类转换

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class _853 {
    static int N = 510;
    static int M = 10010;
    static int n,m,k;  //输入的图的点数和边数和限制的最多边数
    static int dist[] = new int[N];  //存储某点到编号为1的点的最短路径的值
    static int backup[] = new int[N];  //备份数组，存储上一轮循环的 dist
    static Edge edges[] = new Edge[M];   //存储边的数组

    public static void bellmanford(){
        Arrays.fill(dist, 0x3f3f3f3f);   //将 dist 初始化为正无穷
        dist[1] = 0;
        for (int i = 0; i < k; i++) {
            backup = Arrays.copyOf(dist, n + 1);   //拷贝上一轮的dist当备份，本轮用
            for (int j = 0; j < m; j++) {
                int a = edges[j].a;
                int b = edges[j].b;
                int w = edges[j].w;
                dist[b] = Math.min(dist[b], backup[a] + w);
            }
        }
        if (dist[n] > 0x3f3f3f3f/2)
            //此处不是 ==0x3f3f3f3f的原因是：0x3f3f3f3f是一个确定的值，并非真正的无穷大
            // dist[n]有可能确实被更新了（因为有负权边）但实际上并不存在最短路
            // 因为如果存在，一定是在 k 条边以内，dist值一定是一个确定的不那么大的值
            System.out.println("impossible");
        else
            System.out.println(dist[n]);
    }
    public static void main(String[] args) throws Exception {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s[] = bf.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        k = Integer.parseInt(s[2]);

        for (int i = 0; i < m; i++) {
            String s1[] = bf.readLine().split(" ");
            int a = Integer.parseInt(s1[0]);
            int b = Integer.parseInt(s1[1]);
            int w = Integer.parseInt(s1[2]);
            edges[i] = new Edge(a,b,w);
        }
        bellmanford();
    }
}

class Edge{
    int a;
    int b;
    int w;

    public Edge(int a, int b, int w) {
        this.a = a;
        this.b = b;
        this.w = w;
    }
}

SPFA

851.spfa求最短路（！存疑）

与上一题的区别是，数据保证不存在负权回路。

输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式：输出一个整数，表示 1 号点到 n 号点的最短距离。如果路径不存在，则输出 impossible。

数据范围：1≤n,m≤10^5,图中涉及边长绝对值均不超过 10000。

输入样例：

3 3
1 2 5
2 3 -3
1 3 4

输出样例：

2

思路分析

spfa相当于是bellman-ford 算法的优化。观察：

我们可知，只有当 dist[a] 变小时，dist[b] 才会被更新。于是我们定义一个队列 q：

因为只有 dist 变小的点，才有可能在之后再更新其他点的 dist。因此只有松弛成功的点才加入队列。

代码实现（部分）

把850的代码抄过来，把Dijkstra方法改成spfa。

static Queue<Integer> queue = new LinkedList<Integer>();
public static void spfa(){
    Arrays.fill(dist,0x3f3f3f3f);   //初始化将最短路设为无穷大（少一个3f就会有测试点不过）
    dist[1] = 0;   //编号为 1 的点的最短路径是0
    queue.add(1);
    st[1] = true;  //编号1的节点已在队列中
    while (!queue.isEmpty()){
        int t = queue.poll();  //弹出队头
        st[t] = false;
        for (int i = h[t];i != -1;i = ne[i]){  //i是遍历节点t的所有出边
            int j = e[i];   //j是出边对应的终点
            if (dist[j] > dist[t] + w[i]){   //松弛成功
                dist[j] = dist[t] + w[i];
                if (!st[j]) {   //如果j不在队里
                    queue.add(j);
                    st[j] = true;
                }
            }
        }
    }
    if (dist[n] != 0x3f3f3f3f)
        System.out.println(dist[n]);
    else
        System.out.println("impossible");
}

852.spfa判断负环

给一个 n 个点 m 条边的有向图，可能存在重边和自环， 边权可能为负数。判断图中是否存在负权回路。

输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式：如果图中存在负权回路，则输出 Yes，否则输出 No。

数据范围：1≤n≤2000,1≤m≤10000,图中涉及边长绝对值均不超过 10000。

输入样例：

3 3
1 2 -1
2 3 4
3 1 -4

输出样例：

Yes

思路分析

定义一个 cnt 数组，记录某点到编号为1的点的最短路径经过的边数。如果 cnt[i] >= n，说明结点1经过 n条边以上才到达结点 i，那就意味着这整条路径（含起点终点）一共有 n+1 以上个点。图中总共就 n 个点，说明结点 i 的最短路径上有重复的点，即存在环，那就一定是负环（只有负环 最短路径才会被更新）。

细节：开始要把所有点都进队。（如果在上一题采取此也能ac）（具体为什么此处存疑）

代码实现（部分）

static int cnt[] = new int[N];  //存储某点到编号为1的点的最短路径经过的边数
public static boolean spfa(){
    //所有点进队
    for (int i = 1; i <= n; i++) {
        st[i] = true;
        queue.add(i);
    }
    while (!queue.isEmpty()){
        int t = queue.poll();  //弹出队头
        st[t] = false;
        for (int i = h[t];i != -1;i = ne[i]){  //i是遍历节点t的所有出边
            int j = e[i];   //j是出边对应的终点
            if (dist[j] > dist[t] + w[i]){   //松弛成功
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;  //最短路径经过的边数+1
                if (cnt[j] >= n)
                    return true;
                if (!st[j]) {   //如果j不在队里
                    queue.add(j);
                    st[j] = true;
                }
            }
        }
    }
    return  false;
}

Floyd

854.Floyd求最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。数据保证图中不存在负权回路。

输入格式：第一行包含三个整数 n,m,k。接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。

输出格式：共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。

数据范围：1≤n≤200，1≤k≤n^2，1≤m≤20000，图中涉及边长绝对值均不超过 10000。

输入样例：

3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出样例：

impossible
1

思路分析

dp问题分析

f[k] [i] [j] = min(f[k−1] [i] [j] , f[k−1] [i] [k]+f[k−1] [k] [j])

状态转移方程：

dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j])

解释：

根据上述公式，令 j = k得：f[k] [i] [k] = f[k-1] [i] [k]；令 i=k 得：f[k] [k] [j] = f[k-1] [k] [j]。
代入得：f[k] [i] [j] = min(f[k−1] [i] [j], f[k] [i] [k]+f[k] [k] [j])
由于到本轮计算f[k]时，f[k-1]就是上一轮的结果，所以可以去掉最外层循环：f [i] [j] = min(f [i] [j], f [i] [k]+f[k] [j])

代码实现

package acwing.SearchAndGraph.ShortestPath.Floyd;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class _854 {
    static int N = 210;
    static int n,m,k;
    static int INF = (int)1e9;
    static int[][] d = new int[N][N];

    public static void Floyd(){
        for (int p = 1; p <= n ; p++)
            for (int i = 1; i <= n ; i++)
                for (int j = 1; j <= n; j++)
                    d[i][j] = Math.min(d[i][j],d[i][p] + d[p][j]);
    }

    public static void main(String[] args) throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s[] = bf.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        k = Integer.parseInt(s[2]);

        //初始化邻接矩阵
        for (int i = 1; i <= n ; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == j)
                    d[i][j] = 0;
                else
                    d[i][j] = INF;
            }
        }

        //邻接矩阵存储输入的图信息
        for (int i = 0; i < m; i++) {
            String s1[] = bf.readLine().split(" ");
            int x = Integer.parseInt(s1[0]);
            int y = Integer.parseInt(s1[1]);
            int z = Integer.parseInt(s1[2]);
            d[x][y] = Math.min(d[x][y],z);
        }

        Floyd();

        for (int i = 0; i < k; i++) {
            String s2[] = bf.readLine().split(" ");
            int x = Integer.parseInt(s2[0]);
            int y = Integer.parseInt(s2[1]);
            if (d[x][y] > INF/2)
                System.out.println("impossible");
            else
                System.out.println(d[x][y]);
        }
    }
}