最簡單的最短路徑算法 - Floyd_Warshall算法

# 最簡單的最短路徑算法 - Floyd_Warshall算法

標籤（空格分隔）： 算法

---

參考《啊哈算法》第六章第一節，PDF在線閱讀

介紹

詳細介紹請看PDF，個人理解，這是一個暴力+動態規劃的思想，在二維數組中每次都從第1，2，3 … N節點中轉一次，如果可以中轉且路徑較小，那麼我們就更新存儲路徑的二維數組。

這個算法可以解決多源最短路徑問題

時間複雜度

O(N3)

代碼

/**
 * 多源最短路徑
 * Floyd_Warshall算法
 * 時間複雜度 O(N^3)
 */

#include <iostream>
#include <climits>

using namespace std;

int n;

void print(int e[10][10]) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            printf("%15d", e[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int e[10][10] = {0}, m;
    cin >> n >> m;
    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] = INT_MAX;
    int a, b, c;
    for (int i = 1; i <= m; i++) {
        cin >> a >> b >> c;
        e[a][b] = c;
    }

    for (int k = 1; k <= n; k++) { //讓二維數組依次從k點中轉一下
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++) {
                //可以中轉取較小值，無法到達就跳過
                if (e[i][j] > e[i][k] + e[k][j] && e[i][k] != INT_MAX && e[k][j] != INT_MAX)
                    e[i][j] = e[i][k] + e[k][j];
            }
//        print(e);
    }

    print(e);

    return 0;
}

/**
5 8
1 3 2
1 5 4
2 5 2
3 4 3
4 2 5
5 2 5
5 3 3
5 4 1
              0              9              2              5              4
     2147483647              0              5              3              2
     2147483647              8              0              3             10
     2147483647              5             10              0              7
     2147483647              5              3              1              0

4 8
1 2 2
1 3 6
1 4 4
2 3 3
3 1 7
3 4 1
4 1 5
4 3 12
         0         2         5         4
         9         0         3         4
         6         8         0         1
         5         7        10         0
 */