题目大意

给定起点 \(S\) 和终点 \(T\)，求从起点到终点恰好经过 \(N\) （\(N\) 给定）条边的最短路径。

solution

发现本题点数巨多，但是边数小到可怜，我们可以只保留了一部分点，先判断连通性，不连通直接输出即可。

当 \(S\) 和 \(T\) 连通时，我们设 \(G^k\) 为经过 \(k\) 条边后最短路的邻接矩阵。我们发现下面一个事实：

当我们定义矩阵乘法为关于 \(\{min, +\}\) 的运算时，\(G^m \times G^n = G^{n+m}\)。

因此这题就是对邻接矩阵进行一个广义矩阵乘法。

同时我们发现 \(k\) 的范围完全支持我们进行快速幂，因此我们可以用矩阵快速幂，每次矩阵乘法复杂度为 \(|E|^3\)，总复杂度为 \(|E|^3\log k\)。

• 完整代码（远古时期做的了，马蜂不太一样）

#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int k, m, s, e, n;
int g[N][N];
int res[N][N];
unordered_map<int, int> mp;

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N];
    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;
    
    while(k)
    {
        if(k & 1) mul(res, res, g);
        mul(g, g, g);
        k >>= 1;
    }
}

int main()
{
    cin >> k >> m >> s >> e;
    
    if(!mp.count(s)) mp[s] = ++ n;
    if(!mp.count(e)) mp[e] = ++ n;
    
    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int a, b, c;
        cin >> c >> a >> b;
        if(!mp.count(a)) mp[a] = ++ n;
        if(!mp.count(b)) mp[b] = ++ n;
        a = mp[a], b = mp[b];
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    
    qmi();
    
    cout << res[mp[s]][mp[e]] << endl;
    
    return 0;
}