【魔法 / 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))

`代码`

cpp 复制代码

#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;
}