《啊哈！算法》第六章代码上

这一章要普及一些有意思的算法啦~激动（并不）
6.1 Floyd算法

public class Test{
    public static void main(String[] args){
        int[][] e=new int[50][50];
        int n,m;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入点和边的数量");
        n=sc.nextInt();//点
        m=sc.nextInt();//边
        System.out.println("请输出起点、终点和权值");
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j)
                    e[i][j]=0;
                else
                    e[i][j]=9999;
            }
        }
        for(int i=1;i<=m;i++){
            int st=sc.nextInt();
            int ed=sc.nextInt();
            int dis=sc.nextInt();
            e[st][ed]=dis;
        }
        for(int k=1;k<=n;k++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(e[i][k]+e[k][j]<e[i][j])
                        e[i][j]=e[i][k]+e[k][j];
                }
            }
        }
        for(int i=1;i<=n;i++) {
            for (int j = 1; j <= n; j++) {
                System.out.print(e[i][j]+" ");
            }
            System.out.println();
        }
    }
}
/*
1 2 2
1 3 6
1 4 4
2 3 3
3 1 7
3 4 1
4 1 5
4 3 12
 */

floyd算法确实代码量很少，只有5行关键代码，但是它时间复杂度是O(n^3)，可以说是有所得必有所失吧！
6.2 Dijkstra算法

class Test{
    public static void main(String[] args){
        int[][] e=new int[10][10];
        int[] dis=new int[10];
        int[] book=new int[10];
        int n,m,min,inf=9999,tmp=0;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入点和边的数量");
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j)
                    e[i][j]=0;
                else
                    e[i][j]=inf;
            }
        }
        for(int i=1;i<=n;i++)
            book[i]=0;
        System.out.println("请输入起点、终点和权值");
        for(int i=1;i<=m;i++){
            int a1=sc.nextInt();
            int a2=sc.nextInt();
            int len=sc.nextInt();
            e[a1][a2]=len;
        }
        for(int i=1;i<=n;i++)
            dis[i]=e[1][i];
        book[1]=1;
        for(int c=1;c<=n-1;c++) //计数
        {
            min=9999;
            for(int i=1;i<=n;i++){
                if(book[i]==0&&dis[i]!=inf){
                    if(dis[i]<min){
                        min=dis[i];
                        tmp=i;
                    }
                }
            }
            book[tmp]=1;
            for(int j=1;j<=n;j++){
                if(dis[tmp]+e[tmp][j]<dis[j])
                    dis[j]=dis[tmp]+e[tmp][j];
            }
        }
        for(int i=1;i<=n;i++)
            System.out.print(dis[i]+" ");

    }
}
/*
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4
 */

这个算法复杂度降到了O(n^2)，但是相应的，他只是给出了源点到各个目的地的最短路程，如果想打印出完整的二维矩阵，算法复杂度还是要升到n的3次方，但是取最短边松弛确实是一个新颖的想法！