Floyd算法

传送门：

 Dijkstra

 Bellman-Ford

 SPFA

 Floyd

1.算法思想：

定义一个n阶方阵序列：A^(-1) A⁽⁰⁾ A⁽¹⁾ A^{(2) .......} A^(n-1)

A^(-1) [i][j]表示顶点Vi到顶点Vj的直接边的长度，A^(-1) 就是邻接矩阵Edge[n][n]

A⁽⁰⁾ [i][j]表示顶点Vi到顶点Vj，中间顶点（如果有，则）是V0的最短路径长度

A⁽¹⁾ [i][j]表示顶点Vi到顶点Vj，中间顶点序号不大于1的最短路径长度

A⁽²⁾ [i][j]表示顶点Vi到顶点Vj，中间顶点序号不大于2的最短路径长度

A^(n-1) [i][j]表示顶点Vi到顶点Vj最短路径长度

允许带有负权值的边，但不能有负权值回路。

2.代码实现

输入：

4 8
0 1 1
0 3 4
1 2 9
1 3 2
2 0 3
2 1 5
2 3 8
3 2 6

输出：

0->1    1       0->1
0->2    9       0->1->3->2
0->3    3       0->1->3
1->0    11      1->3->2->0
1->2    8       1->3->2
1->3    2       1->3
2->0    3       2->0
2->1    4       2->0->1
2->3    6       2->0->1->3
3->0    9       3->2->0
3->1    10      3->2->0->1
3->2    6       3->2

递推式a[i][j] = min(a[i][j], a[i][k] + a[k][j])

如果只是判断连通性，可改成a[i][j] |= a[i][k] & a[k][j];

此处存路径是按照倒叙存储路径path[i][j]表示从顶点vi到vj的最短路径上顶点j的前一个点的序号，这里有正序存路径使得字典序最小，而且这里必须在初始化的时候初始化path，如果有边就要初始化。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<sstream>
using namespace std;
typedef long long ll;
const int maxn = 1000 + 10;
const int INF = 1 << 25;
int T, n, m, cases;
int Map[maxn][maxn];//存图
int path[maxn][maxn];//存路径，path[i][j]表示从顶点vi到vj的最短路径上顶点j的前一个点的序号
int a[maxn][maxn];//存最短路径长度
void Floyd()
{
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            for(int k = 0; k < n; k++)
            {
                a[i][j] = Map[i][j];
                if(i != j && a[i][j] < INF)path[i][j] = i;//i到j有路径
                else path[i][j] = -1;//从i到j没有直接的路径
            }
        }
    }
    for(int k = 0; k < n; k++)
    {
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(k == i || k == j)continue;
                if(a[i][k] + a[k][j] < a[i][j])
                {
                    a[i][j] = a[i][k] + a[k][j];
                    path[i][j] = path[k][j];
                }
            }
        }
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(i == j)continue;
            printf("%d->%d\t%d\t", i, j, a[i][j]);
            stack<int>q;
            int x = j;
            while(x != -1)
            {
                q.push(x);
                x = path[i][x];
            }
            cout<<q.top();
            q.pop();
            while(!q.empty())
            {
                cout<<"->"<<q.top();
                q.pop();
            }
            cout<<endl;
        }
    }
}
int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i++)for(int j = 0; j < n; j++)Map[i][j] = (i == j ? 0 :INF);
    int u, v, w;
    for(int i = 0; i < m; i++)
    {
        cin >> u >> v >> w;
        Map[u][v] = w;
    }
    Floyd();
    return 0;
}