Presents in Bankopolis （区间dp）

Presents in Bankopolis

[Link](Problem - D - Codeforces)

题意

​ 给你一个有向图，找一条恰好经过$k$个点的最短路径，并且要求每次选的边不能跃过之前已经经过的结点。即对于路径中的边$x\to y$，不存在以前经过的点$t$使得三者编号满足$min(x,y)\le t\le max(x,y)$。

思路

​ 一开始写了个暴力的搜索，$T9$。转化一下题意就等价于在一个长度为$n$的数轴上，从某个点开始走$k-1$步的最短距离，并且当前走的区间不能包含住前面走的点，只有两种走法，往外或者往里，这样区间应该是不断缩小的，我们可以反向思考它，由小的区间往外走，可以用$f[k][i][j][s]:当前走了k步的区间左端点在l右端点r且s=0表示当前在左边s=1表示当前在右边的最短路径$，第一维可以优化掉，做区间$dp$即可，转移满足包含当前区间或者不相交即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> k >> m;
    vector<PII> g[n + 1];
    for (int i = 1; i <= m; i ++) {
        int x, y, z; cin >> x >> y >> z;
        g[y].push_back({x, z});
    }
    vector<vector<vector<int>>> f(n + 1, vector<vector<int>>(n + 1, vector<int>(2, INF)));
    for (int i = 1; i <= n; i ++) f[i][i][0] = f[i][i][1] = 0;

    for (int i = 0; i < k - 1; i ++) {
        vector<vector<vector<int>>> nf(n + 1, vector<vector<int>>(n + 1, vector<int>(2, INF)));
        for (int l = 1; l <= n; l ++)
            for (int r = l; r <= n; r ++) {
                if (f[l][r][0] != INF) {
                    for (auto t : g[l]) 
                        if (t.first < l || t.first > r) {
                            int k1 = min(t.first, l), k2 = max(t.first, r);
                            bool ok = (t.first == k2);
                            nf[k1][k2][ok] = min(nf[k1][k2][ok], f[l][r][0] + t.second);  
                        }                
                       
                }
                if (f[l][r][1] != INF) {                             
                    for (auto t : g[r])
                        if (t.first > r || t.first < l) {
                            int k1 = min(t.first, l), k2 = max(t.first, r);
                            bool ok = (t.first == k2);
                            nf[k1][k2][ok] = min(nf[k1][k2][ok], f[l][r][1] + t.second);
                        }
                       
                }                               
            }
                        
        f = nf;                            
    }

    int res = INF;
    for (int i = 1; i <= n; i ++)
        for (int j = i; j <= n; j ++)
            res = min(res, min(f[i][j][0], f[i][j][1]));

    if (res == INF) res = -1;
    cout << res << '\n';
    return 0;
}