单元点最短路径

 

 

package 贪心算法;

import java.util.Arrays;
import java.util.Scanner;

public class 迪杰斯特拉 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[][] g = creatG();
        print_g(g);
        djstla(g);
    }

    private static void djstla(int[][] g) {
        int n=g.length;//节点数
        String[] color=new String[n];//white：未访问，black：已访问
        int[] pred=new int[n];//结点的前驱，pred[i],  (i,pred[i])表示一段弧
        int[] dist=new int[n];//当前定点的最短路径， 顶点用数组小标表示，从0开始
        Arrays.fill(color,"white");//没有结点被访问
        Arrays.fill(pred,-1);//初始化无前驱，为-1
        Arrays.fill(dist,999);//初始化，距离很大
        Scanner in=new Scanner(System.in);
        int strat=in.nextInt();//源点  求单源点最短路径
        dist[strat]=999;//源点到自身距离为0，这一步至关重要，没有这一步第一个for循环不会对dist值进行修改，则第二个for不会满足松弛操作，最终只有一个结点为black其他都是初值
        for (int i = 0; i < n; i++) {//每次确定一个顶点，需n次
            int mindist=999;
            int rec=0;
            for (int j = 0; j < n; j++) {
                if(color[j].equals("white")&&dist[j]<mindist){//选择距源点最近的白色顶点
                    mindist=dist[j];
                    rec=j;
                }
            }
            for (int v = 0; v < n; v++) {
                if(g[rec][v]!=999&&(dist[rec]+g[rec][v]<dist[v])){//找rec的临接点，更新距离（小于当前距离才更新）即执行松弛操作
                    dist[v]=dist[rec]+g[rec][v];//松弛操作
                    pred[v]=rec;//记录前驱
                }
            }
            color[rec]="black";//结点赋黑
        }
        System.out.println(Arrays.toString(color));
        System.out.println(Arrays.toString(pred));
        System.out.println(Arrays.toString(dist));
    }

    private static void print_g(int[][] g) {
        for (int i = 0; i < g.length; i++) {
            for (int i1 = 0; i1 < g[0].length; i1++) {
                System.out.printf("%-4d", g[i][i1]);
            }
            System.out.println();
        }
    }

    private static int[][] creatG() {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] g = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(g[i], 999);
            g[i][i] = 0;
        }
        int edge = in.nextInt();
        for (int i = 0; i < edge; i++) {
            int s = in.nextInt(), f = in.nextInt(), w = in.nextInt();
            g[s][f] = w;
            //g[f][s] = w;
        }
        return g;
    }
}
/*
7 9
0 1 6
0 3 2
1 2 5
1 5 3
4 6 1
4 5 5
5 2 3
3 1 7
3 4 5

 */

运行结果

 

 若没有

dist[strat]=0;

则会出现