【矩阵乘法 floyd】洛谷_2886 牛继电器Cow Relays

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/SSL_hzb/article/details/84887151

题意

一张 $T$条边的图，点的编号在 $1\sim1000$之间。求出从起点 $S$到终点 $E$刚好经过 $N$条边的最短路。

思路

因为边最多只有 $100$条，而点编号在 $1\sim1000$内，所以点数最多只有 $200$个，然后我们可以先离散化。
离散化数据把它映射到 $1\sim P$的编号中。设 $A$为这个图的邻接矩阵，我们可以看看这个方程：
$b[i][j]=\underset{1\leq k\leq p}{min}(A[i][k]+A[k][j])$
因为 $A$是初始矩阵，所以代表经过 $1$条边的最短路径。然而 $B$是从 $A$得来，我们枚举了一个断点 $k$，所以 $B$是两条边的最短路。
我们设矩阵 $A^n$保存两点之间刚好经过 $n$条路的最短路，可以得出：
$(A^{r+m})[i][j]=\underset{1\leq k\leq p}{min}((A^r)[i][k]+(A^m)[k][j])$
我们发现这个东西和矩阵乘法很像，只不过求和变成求最值，乘积变成和。因为是求最值，显然可以得出这个矩阵乘法也满足结合律，然后我们就可以用快速幂加速来做了。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>

int N, T, S, E, P;
int id[1001];
struct matrix{
    int a[201][201];
}f;

matrix operator *(matrix &a, matrix &b) {
    matrix c;
    memset(c.a, 127 / 3, sizeof(c.a));
    for (int i = 1; i <= P; i++)
        for (int j = 1; j <= P; j++)
            for (int k = 1; k <= P; k++)
                c.a[i][j] = std::min(c.a[i][j], a.a[i][k] + b.a[k][j]);
    return c;
}

void ksm(matrix &f, int b) {
    matrix result = f;//答案先存了f所以指数-1
    for (; b; b >>= 1) {
        if (b & 1) result = result * f;
        f = f * f;
    }
    f = result;
}

int main() {
    scanf("%d %d %d %d", &N, &T, &S, &E);
    memset(f.a, 127 / 3, sizeof(f.a));
    for (int i = 1, x, y, z; i <= T; i++) {
        scanf("%d %d %d", &z, &x, &y);
        x = id[x] ? id[x] : id[x] = ++P;
        y = id[y] ? id[y] : id[y] = ++P;//离散
        f.a[x][y] = f.a[y][x] = std::min(f.a[x][y], z);
    }
    ksm(f, N - 1);
    printf("%d", f.a[id[S]][id[E]]);
}