HIT-软件构造 blog3：

最短路径
​         在图中，不可避免要解决的一个问题就是计算两点之间的最短路径，对于图结构来说，两个点之间不一定只有一条路径，那么如何才能找出最短的那一条就是图中最短路径问题。最短路径问题在实际生活中应用十分广泛。接下来主要介绍两种较为常用的最短路径算法—Dijkstra算法和Floyd算法。

​

迪杰斯特拉算法

思想有点想普利姆算法，利用不断遍历顶点，得到起点到每个顶点的最短路径（普利姆算法得到的是相互连通且相邻的两顶点，前一个顶点到下一个顶点的最小权值，从而形成最小生成树，因此与普利姆算法不同的就是我们要的是第一个顶点（起点）到每一个顶点的最小权值总和）

	/**
	 * Dijistra algorithm
	 */
	public void dijistra() {
		//	判断是否得到其每个顶点的最短路径
		isVisited=new boolean[vertexSize];
		//	记录起点到达每个顶点的最短路径值
		int[] lowcost=new int[vertexSize];
		for(int i=0; i<vertexSize; i++) {
			lowcost[i]=matrix[0][i];
		}
		//	min记录目前所到顶点的最短路径的最小值，minId记录顶点下标
		int min,minId;
		for(int i=0; i<vertexSize; i++) {
			min=MAX;
			minId=0;
			for(int j=0; j<vertexSize; j++) {
				//	如果没有得到J顶点的最短路径和且该位置的最短路径值是目前最小的，就获取
				if(!isVisited[j]&&lowcost[j]<min) {
					min=lowcost[j];
					minId=j;
				}
			}
			//	获取以后，将获取的位置记录为已经获得其最短路径
			isVisited[minId]=true;
			//	
			for(int j=0; j<vertexSize; j++) {
				//	min还是当前的最短路径值中的最小值
				//	min+matrix[minId][j]<lowcost[j]
				//	表示最短路径值位置的出度中能出去到达的位置所需要的路径值(权值)  和    目前最短路径值   的总和   小于    当前位置的最短路径值
				//	说明需要更换最短路径值为前者，因为后者比前者大
				//	Example:
				//			0->1  权值为1   1->2 权值为1   0->2 权值为3  1->3 权值为1
				//	lowcost={0,1,3,M}
				//		min=1;
				//		顶点1出度===={1,0,1,1}，进行遍历
				//		1+1=2<0? -> 1+0=1<1? -> 1+1=2<3?成功，替换 -> 1+1<M?
				//	lowcost={0,1,3,M}  =>> 1+1<3  =>> lowcost={0,1,2,M}  		
				if(!isVisited[j]&&min+matrix[minId][j]<lowcost[j]) {
					lowcost[j]=min+matrix[minId][j];
				}
			}
		}
		for(int i=0;i<vertexSize; i++) {
			System.out.println("v0 -> v"+i+": "+lowcost[i]);
		}
	}
	

f弗罗伊德算法

class Graph{
    char[] vertex;//存放顶点的数组
    int[][] dis;//保存，从各个顶点触发到其它顶点的距离，最后的结果也保留在该数组中
    int[][] pre;//保存到达目标顶点的前驱顶点

    /***
    * @Description: 构造方法
    * @Param: length: 大小
    *          matrix: 邻接矩阵
    *          vertex：顶点数组
    * @Author: xz
    */
    public Graph(int length,int[][] matrix,char[] vertex) {
        this.vertex = vertex;
        this.dis = matrix;
        this.pre = new int[length][length];
        //对pre数组初始化，注意存放的是前驱顶点的下标
        for(int i=0;i<length;i++){
            Arrays.fill(pre[i],i);
        }
    }
    
    /*** 
    * @Description: 显示pre数组和dis数组
    * @Author: xz
    */
    public void show(){
        char[] vertex={'A','B','C','D','E','F','G'};
        for(int i =0;i<dis.length;i++){
            //输出pre数组的一行数据
            for(int j=0;j<dis.length;j++){
                System.out.print(vertex[pre[i][j]]+" ");
            }
            System.out.println();

            //输出dis数组的一行数据
            for(int j=0;j<dis.length;j++){
                System.out.print("("+vertex[i]+"->"+vertex[j]+"最短路径="+dis[i][j]+") ");
            }
            System.out.println();
            System.out.println();
        }
    }
    
    /*** 
    * @Description: 弗洛伊德算法
    * @Author: xz
    */
    public void floyd(){
        //变量保存距离
        int len=0;
        //对中间顶点遍历，k就是中间顶点的下标[A,B,C,D,E,F,G]
        for(int k=0;k<dis.length;k++){
            //从i顶点开始出发[A,B,C,D,E,F,G]
            for(int i=0;i<dis.length;i++){
                //到达j顶点[A,B,C,D,E,F,G]
                for(int j=0;j<dis.length;j++){
                    //从i顶点出发，经过k中间顶点，到达j顶点距离
                    len=dis[i][k]+dis[k][j];
                    if(len<dis[i][j]){
                        dis[i][j]=len;//更新距离
                        pre[i][j]=pre[k][j];//更新前驱顶点
                    }
                }
            }
        }
    }

}