[边数限制最短路 倍增floyd 矩阵优化]Cow Relays G

[边数限制最短路 倍增floyd 矩阵优化]Cow Relays G

题目

思路

边数限制的最短路？bellman_ford可以拿来解决边数<=k的最短路，但这题是边数恰好为k,可以通过奇妙操作改成恰好经过k条边（但我不会）。
这里写倍增floyd解法（只是看着像floyd,但本质不一样）
原本floyd的dp为
$dp[k][i][j]表示i到j经过点1～k最短路径为多少（通过编号确定，不能处理负环）$
现在根据这题把dp改为
$dp[k][i][j]表示从i到j恰好经过k条边的路径（通过边数确定，可以处理负环）$
状态转移,我们枚举中间点k(1~n)
$dp[a+b][i][j]=min(dp[a][i][k]+dp[b][k][j]）$
可以发现任意i到j的过程是独立的，并且具有结合律，那么我们可以用矩阵快速幂去加速。
对比普通floyd和本题的dp转移（类floyd）
普通floyd

void floyd(){
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}

类floyd

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]);

两者的区别是，普通floyd每次会用本次结果来自我更新，而类floyd只用上一次的结果来更新一次，这让边数变的可以控制。
这里去看acwing的这篇题解

代码

$O(N^{3}LogT),N离散化后不超过200$

#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>

using namespace std;

const int N = 210;

int k, n, m, S, E;
int g[N][N];
int res[N][N];

void mul(int c[][N], int a[][N], int b[][N])
{
    static 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;//经过0条边
    while (k)
    {
        if (k & 1) mul(res, res, g);    // res = res * g
        mul(g, g, g);   // g = g * g
        k >>= 1;
    }
}

int main()
{
    cin >> k >> m >> S >> E;

    memset(g, 0x3f, sizeof g);
    map<int, int> ids;
    if (!ids.count(S)) ids[S] = ++ n;//离散化
    if (!ids.count(E)) ids[E] = ++ n;
    S = ids[S], E = ids[E];

    while (m -- )
    {
        int a, b, c;
        cin >> c >> a >> b;
        if (!ids.count(a)) ids[a] = ++ n;
        if (!ids.count(b)) ids[b] = ++ n;
        a = ids[a], b = ids[b];

        g[a][b] = g[b][a] = min(g[a][b], c);
    }

    qmi();

    cout << res[S][E] << endl;

    return 0;
}