动态规划 warshall算法、 Floyd算法

一个有n个顶点的有向图的传递闭包为：有向图中的初始路径可达情况可以参见其邻接矩阵A，邻接矩阵中A[i,j]表示i到j是否直接可达，若直接可达，则A[i,j]记为1，否则记为0；两个有向图中i到j有路径表示从i点开始经过其他点（或者不经过其他点）能够到达j点，如果i到j有路径，则将T[i,j]设置为1，否则设置为0；有向图的传递闭包表示从邻接矩阵A出发，求的所有节点间的路径可达情况，该矩阵就为所要求的传递闭包矩阵。

package reflect.com;
/**
 * 
 * @author shuxing
 * @time 2017年9月5日
 * @project reflect
 */
public class WarShall {
    public static void main(String[] args){
        int [][] arr={
                {0,1,0,0},
                {0,0,0,1},
                {0,0,0,0},
                {1,0,1,0}   
            };
        for(int k=0;k<arr.length;k++){
            for(int i=0;i<arr.length;i++){
                for(int j=0;j<arr[i].length;j++){
                    if(arr[k][j]==1&&arr[i][k]==1)
                        arr[i][j]=1;
                }
            }
        }
        for(int[] m:arr){
            System.out.println();
                for(int n:m)
                    System.out.print(" "+n);
        }   
    }
}

Floyd算法求完全最短路径（要求找到从每个顶点到其他所有顶点之间的距离的最短路径）

/**
 * 
 * @author shuxing
 * @time 2017年9月5日
 * @project reflect
 */
public class Floyd {
    public static void main(String[] args){
        final int Max=10000;
        int [][] arr={
                {0,Max,3,Max},
                {2,0,Max,Max},
                {Max,7,0,1},
                {6,Max,Max,0}   
            };
        for(int k=0;k<arr.length;k++){
            for(int i=0;i<arr.length;i++){
                for(int j=0;j<arr[i].length;j++){
                        arr[i][j]=Math.min(arr[k][j]+arr[i][k],arr[i][j]);
                }
            }
        }
        for(int[] m:arr){
            System.out.println();
                for(int n:m)
                    System.out.print(" "+n);
        }   
    }
}