【魔法 / NOI】

题目

---

思路

动态规划：

状态定义： f [ k ] [ i ] [ j ] 对应使用了不超过 k 次魔法，从 i 到 j 的路径集合 f[k][i][j] 对应使用了不超过k次魔法，从i到j的路径集合 f[k][i][j]对应使用了不超过k次魔法，从i到j的路径集合
状态表示： 路径长度最小值 路径长度最小值 路径长度最小值
目标状态： f [ k ] [ 1 ] [ n ] f[k][1][n] f[k][1][n]
状态转移: f [ k ] [ i ] [ j ] = m i n ( f [ k − 1 ] [ i ] [ t ] + f [ 1 ] [ t ] [ j ] ) , t ∈ [ 1 , n ] f[k][i][j] = min(f[k-1][i][t]+f[1][t][j]), t \in [1,n] f[k][i][j]=min(f[k−1][i][t]+f[1][t][j]),t∈[1,n]
优化：快速幂: 将一个 k 值对应一个矩阵，代表 k 代矩阵。我们就可以将状态转移方程转化为： 将一个k值对应一个矩阵，代表k代矩阵。我们就可以将状态转移方程转化为： 将一个k值对应一个矩阵，代表k代矩阵。我们就可以将状态转移方程转化为：

f k [ i ] [ j ] = m i n ( f k − 1 [ i ] [ t ] , f 1 [ t ] [ j ] ) , t ∈ [ 1 , n ] \begin{align*} f_{k}[i][j] = min(f_{k-1}[i][t], f_{1}[t][j]), t \in [1,n] \end{align*} fk[i][j]=min(fk−1[i][t],f1[t][j]),t∈[1,n]
即该方程给出了k代矩阵的一个元素的计算方式。一个k代矩阵可以依靠一个k-1代矩阵和一个1代矩阵计算出来，类似地：
f k = f k − 1 f 1 f k = ( f k − 2 f 1 ) ( f 1 f 0 ) f k = f 1 k f 0 f 7 = f 4 ( f 2 ( f 1 f 0 ) ) \begin{align*} &f_{k} = f_{k-1}f_{1}\\ &f_{k} = (f_{k-2}f_{1})(f_{1}f_{0})\\ &f_{k} = f_{1}^{k}f_{0}\\ &f_{7} = f_{4}(f_{2}(f_{1}f_{0}))\\ \end{align*} fk=fk−1f1fk=(fk−2f1)(f1f0)fk=f1kf0f7=f4(f2(f1f0))
矩阵间的运算满足结合律，对k重运算可应用快速幂算法
f0就是对于邻接矩阵进行floyd后的矩阵d
枚举所有边进行一次魔法，尝试更新所有f0的路径，使得所有路径都最多用过一次魔法，得到f1

复杂度分析：快速幂复杂度*单个矩阵状态数量*每次状态转移的操作次数：
O ( l o g K ⋅ ( n 3 ) ) \begin{align*} O(logK \cdot (n^{3})) \end{align*} O(logK⋅(n3))

---

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 110, M = 2510;
struct edge{
    int a;
    int b;
    int c;
} edge[M];
LL d[N][N], f[N][N];
int n, m, K;
void mul(LL c[][N], LL a[][N], LL b[][N])
{
    LL temp[N][N];
    memset(temp, 0x3f, sizeof temp);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            for(int k = 1; k <= n; k++)
            {
                temp[i][j] = min(temp[i][j], a[i][k] + b[k][j]);
            }
        }
    }
    
    memcpy(c, temp, sizeof temp);
}
LL qmi()
{
    while(K)
    {
        if(K&1) mul(d, d, f);
        mul(f, f, f);
        K >>= 1;
    }
    
    return d[1][n];
}
int main()
{
    cin >> n >> m >> K;
    memset(d, 0x3f, sizeof d);
    for (int i = 1; i <= n; i ++ ) d[i][i] = 0;
    for(int i = 1; i <= m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edge[i] = {a, b, c};
        d[a][b] = c;
    }
    
    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]);
            }
        }
    }
    memcpy(f, d, sizeof f);
    
    for(int k = 1; k <= m; k++)
    {
        int a = edge[k].a, b = edge[k].b, c = edge[k].c;
        
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                f[i][j] = min(f[i][j], d[i][a] - c + d[b][j]);
            }
        }
    }
    
    cout << qmi();
    return 0;
}