十大算法之Dijkstra算法：

最短路径是图论算法中的经典问题。图分为有向图、无向图，路径权值有正值、负值，针对不同的情况需要分别选用不同的算法。在维基上面给出了各种不同的场景应用不同的算法的基本原则：最短路问题。

针对无向图，正权值路径，采取Dijkstra算法。

如上图，是求a到b的最短路径，这里并不限定b节点，修改为到任意节点的路径，问题是完全一样的。

首先需要记录每个点到原点的距离，这个距离会在每一轮遍历的过程中刷新。每一个节点到原点的最短路径是其上一个节点（前驱节点）到原点的最短路径加上前驱节点到该节点的距离。以这个原则，经过N轮计算就能得到每一个节点的最短距离。

第一轮，可以计算出，2、3、4、5、6到原点1的距离分别为：[7, 9, -1, -1, 14]。-1表示无穷大。取其中最小的，为7，即可以确定1的最短路径为0，2为下一轮的前驱节点。同时确定2节点的最短路径为7，路线：1->2。

第二轮，取2节点为前驱节点，按照前驱节点的最短距离加上该节点与前驱节点的距离计算新的最短距离，可以得到3，4，5，6节点到原点的距离为：[17, 22, -1, -1]，此时需要将这一轮得到的结果与上一轮的比较，3节点：17 > 9，最短路径仍然为9；4节点：22 < 无穷大，刷新4节点的最短路径为22；5节点：不变，仍然为无穷大；6节点：14 < 无穷大，取14，不变。则可以得到本轮的最短距离为：[9, 22, -1, 14]，取最短路径最小的节点，为3，作为下一轮的前驱节点。同时确定3节点的最短路径为9，路线：1->3。

第三轮，同上，以3为前驱节点，得到4，5，6的计算距离为：[20, -1, 11]，按照取最短路径的原则，与上一轮的进行比较，刷新为：[20, –1, 11]，选定6为下一轮的前驱节点。同时取定6的最短路径为11，路线：1->3->6。

第四轮，同上，以6为前驱节点，得到4和5的计算距离为[20, 20]，与上一轮进行比较，刷新后为[20, 20]，二者相等只剩下两个节点，并且二者想等，剩下的计算已经不需要了。则两个节点的最短路径都为20。整个计算结束。4的最短路径为20，路线：1->3->4。5的最短路径为20，路线：1->3->6->5。

如果二者不相等，则还需要进行第五轮，先确定二者中的一个的最短路径和路线，再取定剩下的。直到整个5次循环都完成。

代码如下：

package Graph;

/*
 *Dijkstra，最短路径算法 
 */

public class Dijkstra {

	public static final int M = -1;
	static int[][] map = {
		{ 0,  7,  9,  M,  M, 14 }, 
        { 7,  0,  10, 15, M, M },
        { 9,  10, 0,  11, M, 2 }, 
        { M,  15, 11, 0,  6, M },
        { M,  M,  M,  6,  0, 9 }, 
        { 14, M,  2,  M,  9, 0 }
	};
	static int n =map.length;       //顶点的个数
	static int[] shortest = new int[n];  //存放从start到其他节点的最短路径
	static boolean[] visited = new boolean[n]; //标记当前该顶点的最短路径是否已经求出，true表示已经求出
	
	public static void main(String[] args) {
		int orig = 0; //起始点
		//寻找最短路径
		int[] shortPath = dijkstra_alg(orig);
		
		if(shortPath == null){
			return;
		}
		
		for(int i=0; i< shortPath.length; i++){
			System.out.println("从" + (orig + 1) + "出发到" + (i + 1) + "的最短距离为："+ shortPath[i]);
			}
	}

	private static int[] dijkstra_alg(int orig) {
		// TODO Auto-generated method stub
		// 初始化，第一个顶点求出
        shortest[orig] = 0;
        visited[orig] = true;
		for(int count = 0; count != n-1; count ++)
		{
			//选出一个距离初始顶点最近的为标记顶点
			int k = M;
			int min = M;
			for(int i =0; i< n ; i++)//遍历每一个顶点
			{
				if( !visited[i] && map[orig][i] != M) //如果该顶点未被遍历过且与orig相连
				{
					if(min == -1 || min > map[orig][i]) //找到与orig最近的点
					{
						min = map[orig][i];
						k = i;
					}
				}
			}
			//正确的图生成的矩阵不可能出现K== M的情况
			if(k == M)
			{
				System.out.println("the input map matrix is wrong!");
				return null;
			}
			shortest[k] = min;
		    visited[k] = true;
			//以k为中心点，更新oirg到未访问点的距离
		    for (int i = 0; i < n; i++)
            {
                if (!visited[i] && map[k][i] != M)
                {
                    int callen = min + map[k][i];
                    if (map[orig][i] == M || map[orig][i] > callen)
                    {
                    	map[orig][i] = callen;
                    }
                }
            }
		}
		
		return shortest;
	}
}

运行结果如下：

从1出发到1的最短距离为：0
从1出发到2的最短距离为：7
从1出发到3的最短距离为：9
从1出发到4的最短距离为：20
从1出发到5的最短距离为：20
从1出发到6的最短距离为：11