最短路径算法

迪杰斯特拉（Dijkstra）和弗洛伊德（Floyd）

都不能处理有负权值边的情况

public class Main {
	static int INF = 0x3f3f3f3f;
	/*
	 *Dijkstra思想
	 *将所有节点距离源节点的距离设置为无穷大，
	 *首先从源节点开始，将源节点的距离设置为0，寻找当前还没有被访问过的距离最小的节点（开始时所有节点没有被访问过，所示第一个放入的源节点）
	 *找到当前距离最小的节点后将当前节点标记为访问过的节点
	 *计算当前节点（距离源节点最近）的距离加上到其他节点距离是否小于其他节点的本身距离（如果小于则更新）
	 *n个节点循环N词完成所有节点到源节点的最短路径计算
	 * */
	public static int[] Dijkstra(int[][] graph,int s){
		int nodeNum = graph[0].length;
		int[] vis = new int[nodeNum];
		int[] dist = new int[nodeNum];
		//首先将全部的距离设置为正无穷大
		for(int i=0;i<nodeNum;i++){
			dist[i] = INF;
		}
		dist[s] = 0;
		
		for(int i=0;i<nodeNum;i++){
			int minNumber = INF;
			int now_vis=-1;
			for(int j = 0;j<nodeNum;j++){
				if(vis[j]==0&&dist[j]<minNumber){
					now_vis = j;
					minNumber = dist[j];
				}
			}
			vis[now_vis]=1;
			for(int j=0;j<nodeNum;j++){
				if(vis[j]==0&&(minNumber+graph[now_vis][j]<dist[j])){
					dist[j] = minNumber+graph[now_vis][j];
				}
			}
		}
		return dist;
	}
	/**
	 * Floyd算法
	 **/
	public static int[][] Floyd(int[][] graph){
		int N = graph[0].length;
		int[][] dist = new int[N][N];
		for(int i=0;i<N;i++)
			for(int j=0;j<N;j++)
				dist[i][j]=INF;
		for(int k=0;k<N;k++)
			for(int i=0;i<N;i++)
				for(int j=0;j<N;j++)
					dist[i][j] = Math.min(dist[i][j],graph[i][k]+graph[k][j]);
		return dist;
	}
	public static void main(String[] args){
		int[][] map = new int[7][7];
		for(int i=0;i<7;i++){
			for(int j=0;j<7;j++){
				map[i][j]=INF;
			}
		}
		map[0][1] = 2;map[0][3] = 1;map[1][3] = 3;
		map[1][4] = 10;map[4][6] = 6;map[3][5] = 8;
		map[2][0] = 4;map[2][5] = 5;map[3][2] = 2;
		map[6][5] = 1;map[3][6] = 4;map[3][4] = 2;
		int[] Dres = Dijkstra(map,0);
		int[][] Fres = Floyd(map);
		System.out.println(Dres[6]);
		System.out.println(Fres[0][6]);
    }
}