实现JAVA结合前向量实现Dijkstra

Dijkstra思想：

使用一个dist数组保存到所有其它点的距离；

给定任意一个起点，这个点形成一个集合，这个集合内的所有点，都知道从起点到它的最短距离，对于其他点暂时还不知道；我们需要通过贪心策略，不断扩大这个集合，最终得到到所有点的最短距离。

 选取距离表中【不在最短路径集合内】的最短距离(还没有使用过的点)，就可以得到距离当前集合内最近的一个点，通过这个点贪心的松弛其他点到集合的距离，最后直到所有点都加入到最短路径集合内部，结束。

package com.yxs.graph1;

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Dijkstra {
	static int MAXN = 105;
	static class Edge{
		int to;
		int w;
		int next;
		{
			to = 0;
			w = 0;
			next = 0;
		}
	}
	static int[] head = new int[MAXN];
	static Edge[] edge = new Edge[MAXN];
	static int len = 1;
	static void add(int from, int to, int w) {
		edge[len] = new Edge();
		edge[len].to = to;
		edge[len].w = w;
		edge[len].next = head[from];
		head[from] = len++;
	}
	
	static boolean[] vis = new boolean[MAXN];
	static int[] dist = new int[MAXN];
	static int[] path = new int[MAXN];
	static final int INF = 0x3f3f3f3f;
	static {
		Arrays.fill(vis, false);
		Arrays.fill(dist, INF);
		Arrays.fill(path, 0);
	}
	
	static void dijkstra(int n) {
		dist[1] = 0;
		for(int i = 1;i <= n;i++) {
			int ind = 0;//找一个点距离i最近的点，记录序号			
			for(int j = 1;j <= n;j++) {
				if(!vis[j] && (ind == 0 || dist[j] < dist[ind])) {
					ind = j;
				}
			}
			vis[ind] = true;//找到目前已知的能够到最短距离的点(且没有被调整过)
			for(int j = head[ind];j != 0;j = edge[j].next) {//通过目前知道距离最近的点，调整能够通过这个点到达的所有点，缩短距离。
				if(dist[edge[j].to] > dist[ind] + edge[j].w) {
					dist[edge[j].to] = dist[ind] + edge[j].w;
					path[edge[j].to] = ind;//记录路径
				}
			}
		}
		if(dist[n] == INF) {
			System.out.println("到终点的最短路径不存在");
		}else {
			System.out.println("最短路径的距离为：" + dist[n] + "   具体路径如下：");
			Stack<Integer> stack = new Stack<>();
			for(int i = n;i != 0; i = path[i]) {
				stack.add(i);
			}
			while(!stack.isEmpty()) {
				System.out.print(stack.peek() + "--->");
				stack.pop();
			}
			System.out.println("END");
		}
	}
	
	public static void main(String[] args) {
		Scanner in = new Scanner(new BufferedInputStream(System.in));
		int n = in.nextInt();
		int e = in.nextInt();
		for(int i = 1;i <= e;i++) {
			int from = in.nextInt();
			int to = in.nextInt();
			int w = in.nextInt();
			add(from, to, w);
		}
		dijkstra(n);
	}
	
/*
6 8
1 6 100
1 5 30
1 3 10
2 3 5
3 4 50
4 6 10
5 4 20
5 6 60


*/
	
}