Floyd个人总结＋最小环+传递闭包+做题思路

Flyod主要运用于规模小的情况，比如n<200的时候，通过优化也可以进行300到500的作战，不过很危险，可以运用到负边和判断负圈。
Flyod运用的是动态规划的思想，通过枚举两点之间的中间点来求出所有两点之间的代价。
比如：令k=1，计算所有节点之间（经过节点1、不经过节点1）的最短路径
令k=2,计算所有节点之间（经过节点2、不经过节点2）的最短路径
等等。
可以把这个过程当成点灯，从节点k=1开始操作，想象点亮了这个灯，并以k=1为中转，计算和调整图上所有点之间的最短距离。很显然，对这个灯的邻居是有效的，而对远离它的那些点的计算基本无效。逐步点亮所有的灯，每个电灯就重新计算和调整所有灯之间的最短距离，这些计算用到了以前点灯时得到的结果。
模板：

for (int k = 0; k < n; k++) {
    for (int i = 0; i < n; i++) {
        if (dist[i][k] == INF || i == k) continue;  
        for (int j = 0; j < n; j++) {
            if (dist[i][j] > dist[i][k] + dist[k][j]) dist[i][j] = dist[i][k] + dist[k][j]; 
        }
    }
}

这是我自己看来看去得到的最快的模板了。
最主要的最难理解的就是这个三重循环了，对于k一定要在最外层，原因百度一搜有很多，要多看看不同的人的想法才行，我这里就不写了。
这个道理其实就是，比如k=3循环了一次，那么所有的dist[i][j]就是以k=1、2、3为中转站的，所以当k=n - 1时，就是当所有的点都当中转站的时候，所以这其实就是超级暴力的。
为什么要这么说呢，因为这样就可以来解释解释最小环了：最小环，环嘛，至少也得有3个点，2个点那叫线。那么我们如何在图中用Floyd找到一个最小环呢。比如我们现在有一个环，有当前点k，和它的两个相邻点a,b，那么这个环的最小距离就应该是e[a][k] + e[k][b] + dist[a][b]，因为是相邻点，所以这里的e是相邻距离，而这里的dist[a][b]，指的是从a到b的最短距离，但是我们怎么保证这个最短距离里没有k呢，如果有k，这又怎么是个环呢。画个图解释一下：
这里为了要保证环，我们肯定要让a,b走下面那条没有k的路，可是这怎么保证呢？上面我刚说过，如果走过一次k的循环，那么中转站里就用k来重新调整一次。那么我们只要保证a,b在没有走过k循环的时候就能保证dist[a][b]的最短路径上没有k吗？
所以我们假设k是这个环里面的最大的节点，那么i，j是k的相邻点，那么dist[i][j]的中间点就只有[0,k - 1]了，没有k。所以看下面我贴的代码：在当前k的遍历中，我们在用k来松弛的之前，先拿当前k作为最大点来找最小环，这时候dist[i][j]的中间点一定不存在k，然后这样枚举k就能找到最小环了。（注意，寻找最小环的代码必须要在松弛代码的前面，不然dist[i][j]就不能保证没有当前）

for (int k = 0; k < n; k++) {
    for (int i = 0; i < k; i++)
        for (int j = k + 1; j < n; j++)
            ans = min(ans, dist[a][b] + e[a][k] + e[b][k]);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (j == k || dist[k][j] == INF) continue;
            if (dist[i][j] > dist[i][k] + dist[k][j]) dist[i][j] = dist[i][k] + dist[k][j];
        }
    }
}

传递闭包：

闭包我也不知道是什么东西，不过每次这么用的时候，大家都叫这个方法为传递闭包。举例一道leetcode上面的题：
传送门
这种题我们可以等价为：要求课程a,c中a是否在c之前，转化为是否有路径使得a到c，这就是一个求最短路的，而且规模也很低，我们可以直接写：

const int maxn = 105;
const int INF = 1e9 + 7;
int dist[maxn][maxn];
class Solution {
public:
    vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        for (int i = 0; i < n; i++) for (int j = 0;  j < n; j++) dist[i][j] = INF;
        for (auto &c : prerequisites) dist[c[0]][c[1]] = 1;
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                if (i == k || dist[i][k] == INF) continue;
                for (int j = 0; j < n; j++) {
                    if (dist[i][j] > dist[i][k] + dist[k][j]) dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
        vector<bool> ans;
        for (auto &c : queries) ans.push_back(dist[c[0]][c[1]] != INF);
        return ans;
    }
};

判断负圈：Floyd判断负圈特别的简单，代码也特别的简洁，我们就是直接判断是否有dist[i][i] < 0 就行了，一开始我们设置dist[i][i] = INF，那么计算出来的dist[i][i]是点i出去绕一圈回来的最短距离，如果这个距离小于0的话，那就是有负圈了。
传送门
直接贴ac代码：

#include <iostream>
#include <cstring>

using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1050;
int dist[maxn][maxn];
int n,m,w;
bool Floyd() {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            if (i == k || dist[i][k] == INF) continue;
            for (int j = 1; j <= n; j++)
                if (dist[i][j] > dist[i][k] + dist[k][j]) dist[i][j] = dist[i][k] + dist[k][j];
            if (dist[i][i] < 0) return true;
        }
    }
    return false;
}
int main()
{
    int T; scanf("%d", &T);
    while(T--) {
        scanf("%d%d%d", &n, &m, &w);
        memset(dist, 0x3f3f3f3f, sizeof(dist));
        int a,b,c;
        for (int i = 0; i < m; i++) {
            scanf("%d%d%d", &a, &b, &c);
            if (c < dist[a][b]) dist[a][b] = dist[b][a] = c;
        }
        for (int i = 0; i < w; i++) {
            scanf("%d%d%d", &a, &b, &c);
            dist[a][b] = -c;
        }
        if (Floyd()) puts("YES");
        else puts("NO");
    }
    return 0;
}