Presents in Bankopolis （区间dp）

原创已于 2022-04-15 20:36:01 修改 · 471 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2022-04-03 00:27:12 首次发布

Presents in Bankopolis

[Link](Problem - D - Codeforces)

题意

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

思路

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

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