数据结构 最短路径问题 Floyd算法

数据结构 最短路径问题 Floyd算法

最短路径问题
是图论研究中的一个经典算法问题，旨在寻找图（由结点和边(路径)组成的）中两结点之间的最短路径。算法具体的形式包括：
1、确定起点的最短路径问题：
— 即已知起始结点，求最短路径的问题。适合Dijkstra算法。
2、确定终点的最短路径问题：
— 与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。
在无向图中该问题与确定起点的问题完全等同，
在有向图中该问题等同于把所有路径方向反转的确定起点的问题。
3、确定起点和终点的最短路径问题：
— 即已知起点和终点，求两结点之间的最短路径。
4、全局最短路径问题：
— 求图中所有的最短路径。适合Floyd算法。

最短路径问题算法：
迪杰斯特拉算法（Dijkstra算法）
弗洛伊德算法（Floyd算法）
SPFA算法

弗洛伊德算法（Floyd算法）
一种用于寻找给定的加权图中顶点间最短路径的算法，是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。
Floyd算法的时间复杂度为O(N^3)，空间复杂度为O(N^2)。

Floyd算法基本思想：
Floyd算法是一个经典的动态规划算法。
首先我们的目标是寻找从点i到点j的最短路径：从任意节点i到任意节点j的最短路径不外乎2种可能：
1、直接从i到j
2、从i经过若干个节点k到j
假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，
则设置Dis(i,j) = Dis(i,k) + Dis(k,j)，遍历完所有节点k，则Dis(i,j)中记录的便是i到j的最短路径的距离。

int n = 7；
int a[n][n] = { //初始化S – 将图的邻接矩阵a复制到S中
/A//B//C//D//E//F//G/
/A/ { 0, 12, INF, INF, INF, 16, 14},
/B/ { 12, 0, 10, INF, INF, 7, INF},
/C/ { INF, 10, 0, 3, 5, 6, INF},
/D/ { INF, INF, 3, 0, 4, INF, INF},
/E/ { INF, INF, 5, 4, 0, 2, 8},
/F/ { 16, 7, 6, INF, 2, 0, 9},
/G/ { 14, INF, INF, INF, 8, 9, 0}};

经过更新后的各顶点间最短路径矩阵S:
0 12 22 22 18 16 14
12 0 10 13 9 7 16
22 10 0 3 5 6 13
22 13 3 0 4 6 12
18 9 5 4 0 2 8
16 7 6 6 2 0 9
14 16 13 12 8 9 0

初始状态：S是记录各个顶点间最短路径的矩阵。
第1步：初始化S。
矩阵S中顶点a[i][j]的距离为顶点i到顶点j的权值；如果i和j不相邻，则a[i][j]=∞。实际上，就是将图的邻接矩阵a复制到S中。
a[i][j]：表示矩阵S中顶点i(第i个顶点)到顶点j(第j个顶点)的距离。
第2步：
对于每一对顶点u和v，看看是否存在一个顶点w使得从u到w再到v比己知的路径更短：
以顶点A(第1个顶点)为中介点，若a[i][j] > a[i][0]+a[0][j]，则设置a[i][j]=a[i][0]+a[0][j]。
以顶点a[1][6]，从s中发现a[1][6]=∞；将A作为中介点时，a[1][0] = (B,A)=12，a[0][6] = (A,G)=14，因此B和G之间的距离可以更新为26, 即s[1][6]=26，s[6][1]=26。
以顶点a[0][2]，从s中发现a[0][2]=∞；将B作为中介点时，a[0][1] = (A,B)=12，a[1][2] = (A,B)=10，因此A和C之间的距离可以更新为22, 即s[0][2]=22，s[2][0]=22。
第3步：
同理，依次将顶点B,C,D,E,F,G作为中介点，并更新a[i][j]的大小。

import java.io.IOException;
import java.util.Scanner;

public class MatrixUDG {

    private int mEdgNum;        // 边的数量
    private char[] mVexs;       // 顶点集合
    private int[][] mMatrix;    // 邻接矩阵
    private static final int INF = 100;//Integer.MAX_VALUE;   // 最大值

    public MatrixUDG(char[] vexs, int[][] matrix) {     
        int vlen = vexs.length; // 初始化"顶点数"和"边数"    
        mVexs = new char[vlen]; // 初始化"顶点"
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        mMatrix = new int[vlen][vlen]; // 邻接矩阵： 初始化"边" mMatrix[i][j]=1，则表示"顶点i(即mVexs[i])"和"顶点j(即mVexs[j])"是邻接点；mMatrix[i][j]=0，则表示它们不是邻接点
        for (int i = 0; i < vlen; i++)
            for (int j = 0; j < vlen; j++)
                mMatrix[i][j] = matrix[i][j];
        // 统计"边"
        mEdgNum = 0;
        for (int i = 0; i < vlen; i++)
            for (int j = i+1; j < vlen; j++)
                if (mMatrix[i][j]!=INF)
                    mEdgNum++;
    }

    //返回顶点v的第一个邻接顶点的索引，失败则返回-1
    private int firstVertex(int v) {
        if (v<0 || v>(mVexs.length-1))
            return -1;
        for (int i = 0; i < mVexs.length; i++)
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
                return i;

        return -1;
    }

    // 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
    private int nextVertex(int v, int w) {
        if (v<0 || v>(mVexs.length-1) || w<0 || w>(mVexs.length-1))
            return -1;
        for (int i = w + 1; i < mVexs.length; i++)
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
                return i;
        return -1;
    }

    // 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
    private int nextVertexs(int v) {
        if (v<0 || v>(mVexs.length-1))
            return -1;
        for (int i=0; i < mVexs.length; i++) {
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) {
                System.out.print("邻接点"+mVexs[i]+"权重("+mMatrix[v][i]+")");
            }
        }
        return -1;
    }

    //获取图中的边
    private void getEdges() {
        int index=0;
        System.out.print("edges = "+mEdgNum);
        System.out.println();
        for (int i=0; i < mVexs.length; i++) {
            for (int j=0; j < mVexs.length; j++) {
                if (mMatrix[i][j]!=INF && mMatrix[i][j] != 0) {
                    System.out.println("结点"+mVexs[i]+"和结点"+mVexs[j]+"的边，权重"+mMatrix[i][j]);
                }
            }
        }
        System.out.println();
    }

    /*
     * floyd最短路径。
     * 即，统计图中各个顶点间的最短路径。
     * path -- 路径。path[i][j]=k表示，"顶点i"到"顶点j"的最短路径会经过顶点k。
     * dist -- 长度数组。即，dist[i][j]=sum表示，"顶点i"到"顶点j"的最短路径的长度是sum。
     */
    public void floyd(int[][] path, int[][] dist) {
        // 初始化
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++) {
                dist[i][j] = mMatrix[i][j];    // "顶点i"到"顶点j"的路径长度为"i到j的权值"。
                path[i][j] = j;                // "顶点i"到"顶点j"的最短路径是经过顶点j。
            }
        }
        // 计算最短路径
        for (int k = 0; k < mVexs.length; k++) {
            for (int i = 0; i < mVexs.length; i++) {
                for (int j = 0; j < mVexs.length; j++) {

                    // 如果经过下标为k顶点路径比原两点间路径更短，则更新dist[i][j]和path[i][j]
                    int tmp = (dist[i][k]==INF || dist[k][j]==INF) ? INF : (dist[i][k] + dist[k][j]);
                    if (dist[i][j] > tmp) {
                        // "i到j最短路径"对应的值设，为更小的一个(即经过k)
                        dist[i][j] = tmp;
                        // "i到j最短路径"对应的路径，经过k
                        path[i][j] = path[i][k];
                    }
                }
            }
        }
        // 打印floyd最短路径的结果
        System.out.printf("最短路径矩阵: \n");
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++)
                System.out.printf("%2d  ", dist[i][j]);
            System.out.printf("\n");
        }

        System.out.println();
        System.out.printf("最短路径经过的顶点矩阵: \n");
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++)
                System.out.printf("%2d  ", path[i][j]);
            System.out.printf("\n");
        }
    }

    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int matrix[][] = { 
                 /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
         /*A*/ {   0,  12, INF, INF, INF,  16,  14},
         /*B*/ {  12,   0,  10, INF, INF,   7, INF},
         /*C*/ { INF,  10,   0,   3,   5,   6, INF},
         /*D*/ { INF, INF,   3,   0,   4, INF, INF},
         /*E*/ { INF, INF,   5,   4,   0,   2,   8},
         /*F*/ {  16,   7,   6, INF,   2,   0,   9},
         /*G*/ {  14, INF, INF, INF,   8,   9,   0}};       

        int length = vexs.length;
        int i=0, j;

        System.out.print("结点表： \n");
        for(char label:vexs) {
            System.out.print("结点"+i+", 标识"+label+"\n");
            i++;
        }

        System.out.print("\n");
        System.out.print("邻接矩阵： \n");
        for(i=0; i<length; i++){
            for(j=0; j<length; j++) {
                System.out.printf("%2d  ", matrix[i][j]);
            }
            System.out.print("\n");
        }
        System.out.print("\n");

        MatrixUDG pG;
        pG = new MatrixUDG(vexs, matrix);

        //pG.getEdges();

        for(i=0; i<length; i++){
            //System.out.printf("顶点%d邻接点%d\n", i, pG.firstVertex(i));
            System.out.print("顶点"+vexs[i]);
            pG.nextVertexs(i);
            System.out.print("\n");
        } 
        System.out.print("\n");

        int[][] path = new int[pG.mVexs.length][pG.mVexs.length];
        int[][] floy = new int[pG.mVexs.length][pG.mVexs.length];
        // floyd算法获取各个顶点之间的最短距离
        pG.floyd(path, floy);
    }
}