Floyd倍增 —— 洛谷P2886 [USACO07NOV]Cow Relays G

首先，我们有两个矩阵，如果其中一个矩阵代表恰好经过x条边的最短路，另外一个矩阵代表恰好经过y条边的最短路。那么将这两个矩阵合并就代表恰好经过x+y条边的最短路。怎么合并呢？结合下面这个式子理解一下：c[i][j]=min(c[i][j],a[i][k]+b[k][j]);
其中i,j,k就是floyd三层循环里的i,j,k ;而a矩阵是经过x条边的最短路，b矩阵是经过y条边的最短路，那么c矩阵就是我们得到的经过x+y条边的最短路了。
那么我们依据初始输入的数组(也就是只经一条边两个点的距离),这样转移n-1次，就可以得出我们想要的答案了；
然而由于边数过大，这样显然会炸啊！那怎么办呢？我们可以借助类似快速幂的操作去实现。
另外我们还可以将编号离散化。
代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <unordered_map>

using namespace std;

const int N = 210, INF = 0x3f3f3f3f;

int k, n, m, S, E;
int g[N][N], res[N][N];
unordered_map<int, int> q; // 点的数量太多,而边的数量很少,需要进行离散化.

void floyd(int c[][N], int a[][N], int b[][N]) 
{
    static int temp[N][N]; // c数组和a数组是同一个数组,避免发生冲突需要一个缓冲数组.
    memset(temp, 0x3f, sizeof temp);
    for (int k = 1; k <= n; k ++ ) 
        for (int i = 1; i <= n; i ++ ) 
            for (int j = 1; j <= n; j ++ ) 
                temp[i][j] = min(temp[i][j], a[i][k] + b[k][j]);
    
    memcpy(c, temp, sizeof temp);
}

void qmi() 
{
    memset(res, 0x3f, sizeof res);
    for (int i = 1; i <= n; i ++ ) res[i][i] = 0; // 零元,相当于快速幂中的1,1即为乘法的零元.
    
    while (k) 
    {
        if (k & 1) floyd(res, res, g);
        k >>= 1;
        floyd(g, g, g);
    }
}

int main() 
{
    cin >> k >> m >> S >> E;
    memset(g, 0x3f, sizeof g); // 最少经过一条边,所以不用初始化为0.
    
    q[S] = ++ n, q[E] = ++ n;
    while (m -- ) 
    {
        int a, b, c;
        cin >> c >> a >> b;
        if (!q.count(a)) q[a] = ++ n;
        if (!q.count(b)) q[b] = ++ n;
        a = q[a], b = q[b];
        
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    
    qmi();
    
    cout << res[q[S]][q[E]] << endl;
    
    return 0;
}