最短路径——迪杰斯坷垃算法（有向图、单源最短路径）

最短路径的算法有两种：迪杰斯坷垃算法和弗洛伊德算法。

但是两种算法各有优劣：

迪杰斯坷垃算法适合单源点最短路径的获取，

弗洛伊德算法适合各点间最短路径的获取，即多源点最短路径的获取；

今天主要讲解迪杰斯坷垃算法。

一、算法步骤：

1、获取邻接矩阵，确定起始点start；

2、找到起始点到所有点的距离最短的点k；

3、从k点出发找到距离其他所有点的距离，判断start-->k+k-->i是否小于start-->i,如果成立，则将start到i的最短路径换成start-->k+k-->i

4、重复2、3步，知道每个点都被遍历；

二、代码展示：

public class d4 {
	static int M=10000;//此路不通，此处绝对不可为Integer的最大值或与邻接矩阵中任意一个点的距离相加超出Integer范围的值
	public static void main(String[] args) {
		int[][] weith={
		    {0,10,M,30,100},  
	            {M,0,50,M,M},  
	            {M,M,0,M,10},  
	            {M,M,20,0,60},  
	            {M,M,M,M,0} 
		};
		int start=0;
		int[] shortpath=dijkstra(weith,start);
		for(int i=0;i<shortpath.length;i++){
			System.out.println("从"+start+"到"+i+"的距离为："+shortpath[i]);
		}
	}
	private static int[] dijkstra(int[][] weith, int start) {
		// TODO Auto-generated method stub
		int n=weith.length;//获取顶点个数
		String[] path=new String[n];//记录最短路径经过的顶点
		int[] shortpath=new int[n];//记录最短路径的距离
		int[] visited=new int[n];//记录是否被求出，若被求出值为1
		for(int i=0;i<n;i++){
			path[i]=new String(start+"-->"+i);
		}
		shortpath[start]=0; 
		visited[start]=1;
		for(int count=1;count<n;count++){
			int k=-1;//从未被标记的点中找出最短路径的点
			int dmin=Integer.MAX_VALUE;//获取start到k点的最短路径的距离
			for(int i=0;i<n;i++){
				if(visited[i]!=1&&weith[start][i]<dmin){
					k=i;
					dmin=weith[start][i];
				}
			}
			shortpath[k]=dmin;
			visited[k]=1;
			for(int i=0;i<n;i++){
				if(visited[i]!=1&&weith[start][k]+weith[k][i]<weith[start][i]){
					path[i]=path[k]+"-->"+i;
					weith[start][i]=weith[start][k]+weith[k][i];
				}
			}
		}
		for(int i=0;i<shortpath.length;i++){
			System.out.println("从"+start+"到"+i+"的最短路径为："+path[i]);
		}
		System.out.println("=====================================");
		return shortpath;
	}
	
}

三、结果：

从0到0的最短路径为：0-->0
从0到1的最短路径为：0-->1
从0到2的最短路径为：0-->3-->2
从0到3的最短路径为：0-->3
从0到4的最短路径为：0-->3-->2-->4
=====================================
从0到0的距离为：0
从0到1的距离为：10
从0到2的距离为：50
从0到3的距离为：30
从0到4的距离为：60