全点对间最短路径（弗洛伊德算法）

之前学单源最短路径的时候，学到狄克斯特拉算法，我在想，如果对每个顶点都求它的单源最短路径，那不就可以得到全点对之间的最短路径了吗？这样算下来时间复杂度在O(|V|(|V|+|E|)log|V|)

但是，狄克斯特拉算法有个问题，不能适用于权值为负数的边，所以，当有权值为负数的边的时候，需要用到弗洛伊德算法。弗洛伊德算法的时间复杂度为O(|V|³),其思想就是动态规划的思想。

用A[i,j]来记录从节点i到节点j的最短路径。然后使用一个中间节点k，对于i到j的最短路径，有A[i][j] = min(A[i][j],A[i][k]+A[k][j])。其实就类似于在地图软件上面设置从起点到终点的路径必须经过中间某个地点。k就是i到j当前路径必须经过的节点。

通过上面的状态转移方程，就可以直接敲代码了。

题目：GRL_1_C

AC代码:

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
typedef long long ll;

#define MAXV 105
#define MAXE 9905
const ll INF = (1LL<<32);
int v, e;

ll G[MAXV][MAXV];

void floyd()
{
    for (int k = 0; k < v; ++k)
    {
        for (int i = 0; i < v; ++i)
        {
            if (G[i][k] == INF)
                continue; //i到k不存在路径

            for (int j = 0; j < v; ++j)
            {
                if (G[k][j] == INF)
                    continue;

                G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin >> v >> e;
    ll s, t, d;

    for (int i = 0; i <v; ++i)
        for (int j = 0; j <v; ++j)
            G[i][j] = (i==j?0:INF);
    
    

    for (int i = 0; i < e; ++i)
    {
        cin >> s >> t >> d;
        G[s][t] = d;
    }

    floyd();

    bool is_negative_cycle = false;
    for (int i = 0; i < v; ++i)
    {
        if (G[i][i] < 0)
        {
            is_negative_cycle = true;
            break;
        }
    }

    if(is_negative_cycle)
    {
        cout<<"NEGATIVE CYCLE"<<endl;
        return 0;
    }

    for(int i=0;i<v;++i)
    {
        for(int j=0;j<v;++j)
        {
            if(j) cout<<' ';
            if(G[i][j]==INF)
                cout<<"INF";
            else cout<<G[i][j];

            
            
        }
        cout<<endl;
    }
}

转载请注明来源：https://www.longjin666.top/?p=758

欢迎关注我的公众号“灯珑”，让我们一起了解更多的事物~