Dijkstra算法-最短路径算法

Dijkstra算法是求单源最短路径

主要思想就是先初始化例如起点为1

先初始化点1 到各点的距离，dis[]

然后用一个数组book[]标记那些点已经用了.该假设先标记点1，

然后从没被标记的点中选出一个到源点1最近的点

遍历这个点能到达哪些点，然后更新dis[]

如果不明白直接看代码

package 啊哈;
import java.util.Arrays;
import java.util.Scanner;

public class Dijkstra算法单源最短路径 {
    static int[][] e=new int[10][10];//存储图
    static int[] dis=new int[10];//存储源点到各点的距离
    static boolean book[]=new boolean[10];//标记数组
    static int n,m;
    static int inf=99999999;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<10;i++)
            Arrays.fill(e[i],0);
            
        
        Arrays.fill(book,false);
        Arrays.fill(dis,inf);
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(i==j) e[i][j]=0;
                else e[i][j]=inf;//初始化图的数组
        
        for(int i=1;i<=m;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int c=sc.nextInt();
            e[a][b]=c;//无向图
        }
        
        for(int i=1;i<=n;i++)
            dis[i]=e[1][i];//初始化dis数组
        
        book[0]=true;//标记源点，已被使用
        int min;
        for(int i=1;i<n;i++){//源点被标记，只需遍历剩余的n-1个点
            min=inf;
            int u = 0;
            for(int k=1;k<=n;k++){//寻找没被标记切距离源点最近的点
                if(book[k]==false&&dis[k]<min){
                    min=dis[k];
                    u=k;
                }
            }
            book[u]=true;//标记最近点
            
            for(int j=1;j<=n;j++){//通过这个最近点更新数组dis
                if(e[u][j]<inf)//判断是否连通
                if(dis[j]>dis[u]+e[u][j]){//距离更新，类似于Floyd算法，即原先源点到j点的距离可以通过点u来缩短
                    dis[j]=dis[u]+e[u][j];//更新距离
                }
            }
        }
        
        for(int i=1;i<=n;i++){
            System.out.print(dis[i]+" ");
        }
        
    }

}
但是这个算法不能处理带有负权边的图，又因为带有负权边的图会改变已经更新的点的路程

例如2已经更新了

1->2  2

2->3 2

1->3 3

3->2 -3

这样更新到3的时候又会把1->2 更新了，

这样更新之后的距离为

1->2 0

1->3 3

这样的话1->3 可以更短

从1->3->2->3 2,但是没有计算到