挑战程序设计竞赛（算法和数据结构）——13.3单源最短路径（dijkstra算法）的JAVA实现

Posted 2022-01-02 小乖乖的臭坏坏

题目：

代码：

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.util.Scanner;

public class SingleSourceShortestPath 
    public static void main(String[] args) 
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        int n = cin.nextInt();
        //初始化邻接矩阵M
        int M[][] = new int[n][n];
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                M[i][j] = -1;
            
        

        //完成输入并确定了邻接矩阵
        for (int i=0;i<n;i++)
            int id = cin.nextInt();
            int k = cin.nextInt();
            for (int j=0;j<k;j++)
                int v = cin.nextInt();
                int c = cin.nextInt();
                M[id][v] = c;
            
        

        String color[] = new String[n];
        int d[] = new int[n];//用于记录起点s到v的最短路径成本
        int p[] = new int[n];//用于记录顶点v在最短路径树中的父节点

        dijkstra(color, d, p, M, n);
    

    public static void dijkstra(String color[], int d[], int p[], int M[][], int n)
        int u = -1;

        //将顶点u的color[u]设为white，d[u]初始化为Integer.Maxmum
        for (int i=0;i<n;i++)
            color[i] = "white";
            d[i] = Integer.MAX_VALUE;
        

        //从节点0开始，节点0到起点距离为0，父节点设置为-1
        d[0] = 0;
        p[0] = -1;

        //不停循环
        while (true)
            int mincost = Integer.MAX_VALUE;//先把mincost设为极大值
            for (int i=0;i<n;i++)//对每一个节点进行以下判断与操作
                if(!color[i].equals("black") && d[i]<mincost)//只要该节点还没有被处理，并且该节点比mincost小
                    //那就更新mincost，并且把这个节点设置为当前节点u
                    mincost = d[i];
                    u = i;
                
            

            if(mincost==Integer.MAX_VALUE)break;//如果所有的节点都被处理，那么mincost就会是极大值，那么推出循环

            color[u] = "black";//此时，当前节点已经被处理完毕。以下代码建立当前节点与T集的连接关系

            for (int v=0;v<n;v++)//对于任何一个节点v来讲，执行以下操作
                if(!color[v].equals("black") && M[u][v]!=-1)//只要v是u的领边，且不在T集中（没被处理过）
                    if(d[u] + M[u][v]<d[v])//进一步，到v的总距离只要比从u过来的距离大
                        d[v] = d[u] + M[u][v];//那么就更新到v的距离d[v]
                        p[v] = u;//并且将v的父节点设置为u
                        color[v] = "grey";//v的状态设置为正在处理中的"grey"
                    
                
            
        

        for (int i=0;i<n;i++)
            System.out.println(i + " " + (d[i]==Integer.MAX_VALUE?-1:d[i]));//打印结果
        
    

输入：

5
0 3 2 3 3 1 1 2
1 2 0 2 3 4
2 3 0 3 3 1 4 1
3 4 2 1 0 1 1 4 4 3
4 2 2 1 3 3

输出：

0 0
1 2
2 2
3 1
4 3