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

162 阅读 0 评论 107 点赞

我是靠谱客的博主调皮项链，这篇文章主要介绍[边数限制最短路倍增floyd 矩阵优化]Cow Relays G[边数限制最短路倍增floyd 矩阵优化]Cow Relays G，现在分享给大家，希望可以做个参考。

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

题目

在这里插入图片描述

思路

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

复制代码

1
2
3
4
5
6
7
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

复制代码

1
2
3
4
5
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^3LogT),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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#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;
}