BZOJ1003/luogu1772/ZJOI2006 物流运输

最新推荐文章于 2020-06-06 11:43:00 发布

原创最新推荐文章于 2020-06-06 11:43:00 发布 · 389 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#BZOJ #题解 #最短路 #图论 #DP

dp 同时被 2 个专栏收录

13 篇文章

订阅专栏

图论

4 篇文章

订阅专栏

本文探讨了一种结合图论与动态规划(DP)的有趣算法问题。通过分析特定的数据范围，采用状态压缩DP的方法解决路径选择问题。文章详细介绍了算法实现过程，包括关键的转移方程推导、暴力求解最小费用的gg数组方法及具体实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

很有趣的一道图论+DP。

首先看数据范围，m小于等于20，直观感受状压DP…不过蒟蒻并没有想出来怎么转移。
有一个自然而然的想法：能不能每次将堵塞的边的代价加上去，然后最后求一次最短路？但是这样很难维护转多少次，所以PASS.
于是我就可耻的看了一下题解区。
首先我们先列这样一个转移方程：
$dp[i] = min\{ dp[k] + g[k + 1][i] * (i - k) + K \}$
其中， $dp[i]$ 表示前 $i$ 天中的最小花费，那么我们可以枚举每一个位置看是否进行换路。
如果换路的话，那么从第 $k + 1$ 天到第 $i$ 天试用的最小值就用 $g[k + 1][i]$ 来储存。
所以现在的问题集中在了如何求 $g$ 数组上。
结论也很简单：暴力。
我们枚举每一个天数区间 $[L, R]$ ，首先得到这段时间内哪些点是可以通过，然后对剩余部分求一次最短路，即可求出在 $[L, R]$ 中需要的最小花费。
需要注意的细节蛮多的。

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
#include <cctype>
using namespace std;
inline void read(int &x) {
    x = 0; char c = getchar();
    while(!isdigit(c)) c = getchar();
    while(isdigit(c)) x = x * 10 + c - '0', c = getchar();
}
struct node{
    int to, va;
};
vector<node> v[23];
vector<int> day[103];
int g[103][103];
int dp[103];
int n, m, K, e, d;
inline void add_edge(int a, int b, int c) {
    node tmp;
    tmp.to = b, tmp.va = c;
    v[a].push_back(tmp);
    tmp.to = a;
    v[b].push_back(tmp);
}
queue<int> q;
int minV[23];
bool canuse[23];
inline void getSub(int l, int r) {
    memset(canuse, 1, sizeof canuse);
    for(int i = l; i <= r; ++i) {
        for(int j = 0; j < day[i].size(); ++j)
            canuse[day[i][j]] = 0;
    }
    while(!q.empty()) q.pop();
    q.push(1);
    for(int i = 2; i <= m; ++i)
        minV[i] = 0x3fffff;
    minV[1] = 0;
    int tmp;
    while(!q.empty()) {
        tmp = q.front();
        q.pop();
        for(int i = 0; i < v[tmp].size(); ++i) {
            if(canuse[v[tmp][i].to]) {
                if(minV[tmp] + v[tmp][i].va < minV[v[tmp][i].to]) {
                    minV[v[tmp][i].to] = minV[tmp] + v[tmp][i].va;
                    q.push(v[tmp][i].to);
                }
            }
        }           
    }
    g[l][r] = minV[m];
}
int main() {
    read(n), read(m), read(K), read(e);
    int tr, tt, tv;
    for(int i = 1; i <= e; ++i) {
        read(tr), read(tt), read(tv);
        add_edge(tr, tt, tv);
    }
    read(d);
    for(int k = 1; k <= d; ++k) {
        read(tr), read(tt), read(tv);
        for(int i = tt; i <= tv; ++i)
            day[i].push_back(tr);
    }
    for(int i = 1; i <= n; ++i) {
        for(int j = i; j <= n; ++j) {
            getSub(i, j);
        }
    }
    for(int i = 1; i <= n; ++i) {
        dp[i] = g[1][i] * i;
        for(int k = 1; k < i; ++k) {
            dp[i] = min(dp[i], dp[k] + g[k + 1][i] * (i - k) + K);
        }
    }
    cout<<dp[n]<<endl;
    return 0;
}