2020/11/5bellman_ford 算法

题目

给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从1号点到n号点的最多经过k条边的最短距离，如果无法从1号点走到n号点，输出impossible。

注意：图中可能 存在负权回路 。

输入格式
第一行包含三个整数n，m，k。

接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式
输出一个整数，表示从1号点到n号点的最多经过k条边的最短距离。

如果不存在满足条件的路径，则输出“impossible”。

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

输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3

源代码

import java.util.*;
class Node {
    int a; //起始节点
    int b; //终止节点
    int c; //边长
    Node(int a,int b,int c){
        this.a=a;
        this.b=b;
        this.c=c;
    }
}
class Main{
    static int n;
    static int m;
    static int k;
    static int M=10010;
    static int N=510;
    static int INF=0x3f3f3f3f;
    static int[] dis=new int[N];
    static Node[] list=new Node[M];
    static int[] back=new int[N];
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        k=sc.nextInt();
        for(int i=0;i<m;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int c=sc.nextInt();
            list[i]=new Node(a,b,c);
        }
        Arrays.fill(dis,INF);
        dis[1]=0;
        int res=bellman_ford();
       if (res==-1) System.out.print("impossible");
       else System.out.print(res);
    }
    public static int bellman_ford(){
       for(int i=0;i<k;i++){
        back=Arrays.copyOf(dis,n+1);
        for(int j=0;j<m;j++){
            int a=list[j].a;
            int b=list[j].b;
            int c=list[j].c;
            if(dis[b]>back[a]+c) dis[b]=back[a]+c;
        }   
       }
       if (dis[n]>INF/2) return -1;
       return dis[n];
       
    }
}

自问自答

Q: 为什么要使用Node这个类呢?而不是邻接矩阵或者邻接表呢?
A:因为Bellman_ford算法是针对边的,要求对所有的边做k次更新.我们的Node类存储的就是边的信息,并且建一个Node数组来保存这所有边,到时候只要遍历索引就可以轻易的更新所有边了.
而如果使用邻接表/邻接矩阵,其实他们更关心的是节点,能够做到给一个点找到其邻节点并找到距离(邻接表),或者是找到任意两节点间的距离. 对于邻接表,我们遍历边是很困难的;而对于邻接矩阵,遍历边则是复杂的(因为有的边是不存在的),因此这里直接使用一个新的结构存储边,就是为了方便遍历边.

Q:为什么最后寻找dis[n]时,不存在的条件不是判断INF,而是INF/2?
A:因为更新是对边的,而如果a节点到b节点间的距离是负数,而dis[a]和dis[b]都是INF(也就是不可达),dis[b]同样会更新(因为INF-n一定小于INF),因此可能虽然同样是不可达,但是距离会小于INF. 但是不会太小,INF/2就足够了

Q:为什么要备份?
A:因为每次更新是各条边同时进行的,不能有互相影响的,所以要留备份来作为更新的条件.

总结

最短路径算法一定要有的 是dis[]数组来记录到某点的最短路径,INF表示无穷大(0x3f3f3f3f),并且一定要用INF初始化dis数组,再把起点修改(以1为起点的话就是dis[1]=0)