很有趣的一道图论+DP。
首先看数据范围,m小于等于20,直观感受状压DP…不过蒟蒻并没有想出来怎么转移。
有一个自然而然的想法:能不能每次将堵塞的边的代价加上去,然后最后求一次最短路?但是这样很难维护转多少次,所以PASS.
于是我就可耻的看了一下题解区。
首先我们先列这样一个转移方程:
dp[i]=min{dp[k]+g[k+1][i]∗(i−k)+K}
其中,
dp[i]
表示前
i
天中的最小花费,那么我们可以枚举每一个位置看是否进行换路。
如果换路的话,那么从第
所以现在的问题集中在了如何求
g
数组上。
结论也很简单:暴力。
我们枚举每一个天数区间
需要注意的细节蛮多的。
#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;
}