题目描述:hihocoder.com/problemset/problem/1035
看了题目后没有任何思路,于是看了这篇文章:http://blog.csdn.net/acmmaxx/article/details/38023667
解题思路:
dp[i][0]:只有人可以走,且最后必须回来
dp[i][1]:只有人可以走,最后可以不会来
dp[i][2]:人车都可以走,且人和车都必须回来
dp[i][3]:人车都可以走,人必须回来,车可以不会来
dp[i][4]:人车都可以走,人车都可以不会来
其中:dp[i][1]<=dp[i][0], dp[i][4]<=dp[i][3]<=dp[i][2], dp[i][4]<=dp[i][1], 所以最后取dp[1][4]
假设某个节点为fa, 其某一子节点为son, w1(fa,son)表示步行的代价,w2(fa,son)表示开车的代价
则:
dp[fa][0]=∑(2*w1(fa,son) + dp[son][0])
dp[fa][2]=∑min(2*w1(fa,son) + dp[son][0], 2*w2(fa,son) + dp[son][2])
对于dp[fa][1]:
若最后人不回来,则必定是访问最后一棵子树时没有回来,即:w1(fa,son) + dp[son][1];其余子树人都必须回来,即:2*w1(fa,son) + dp[son][0]
若最后人回来了,则退化为dp[fa][0]
对于dp[fa][3]:
若最后车不会来,则必定有一次访问,人把车开走了,却没把车开回来,并且这次访问应发生在最后一次才能保证总的访问代价最小,即:w2(fa,son) + w1(fa,son) +dp[son][3],其余访问均为:t=min(2*w1(fa,son)+dp[son][0], 2*w2(fa,son)+dp[son][2])
若最后车回来了,则退化为dp[fa][2]
对于dp[fa][4]:
若最后人不会来,则必定发生在最后一次:
1:最后一次访问时,有车
则最后一次为:min(w1(fa,son) + dp[son][1], w2(fa,son) + dp[son][4]),其余均为t=min(2*w1(fa,son)+dp[son][0], 2*w2(fa,son)+dp[son][2])
2:最后一次访问时,无车
则最后一次为:w1(fa,son) + dp[son][1],其余访问中,必定有一次人把车开走,且没开回来,这次是总的倒数第二次,即:w2(fa,son) + dp[son][3] + w1(fa,son),其余均 为t=min(2*w1(fa,son)+dp[son][0], 2*w2(fa,son)+dp[son][2]),这种情况应注意最后两次不能是同一颗子树
若最后人回来了,则退化为dp[fa][3]
代码也基本来源于本文参考的那篇
#include <stdio.h>
#include <string.h>
#define MAX_N 1000000
#define INF (long long)1 << 62
//N:节点总数;FEdge[]存储第一条边;isKey[]表示是否关键;Key[i]存储i和i的子树中关键节点的个数
int N, FEdge[MAX_N+1], isKey[MAX_N+1], Key[MAX_N+1];
long long dp[MAX_N+1][5];
typedef struct Node{
int to, c0, c1, next; //to表示终点
}Edge;
//树有N-1条边,无向边存两次
Edge edge[MAX_N*2];
void AddEdge(int u, int v, int c0, int c1, int t){
edge[t].to = v;
edge[t].c0 = c0;
edge[t].c1 = c1;
edge[t].next = FEdge[u];
FEdge[u] = t;
}
long long min(long long a, long long b){
return a < b ? a : b;
}
void DFS(int u, int fa){//当前节点,其父节点
int i, v, matchf, matche;
long long t, temp1, temp3, temp4, f1, f2, e1, e2, ff, ee, temp;
Key[u] = isKey[u];
dp[u][0] = 0;
dp[u][2] = 0;
temp1 = 0, temp3 = 0, temp4 = 0, f1 = INF, f2 = INF, e1 = INF, e2 = INF, temp = 0;
matche = -1, matchf = -1;
for(i = FEdge[u]; i + 1; i = edge[i].next){
v = edge[i].to;
if(v != fa){
DFS(v, u);
Key[u] += Key[v];
if(Key[v]){
dp[u][0] += 2*edge[i].c0 +dp[v][0];
t = min(2*edge[i].c0+dp[v][0], 2*edge[i].c1+dp[v][2]);
dp[u][2] += t;
temp1 = min(temp1, dp[v][1] - dp[v][0] - edge[i].c0);
temp3 = min(temp3, edge[i].c1 + edge[i].c0 + dp[v][3] - t);
temp4 = min(temp4, min(edge[i].c0+dp[v][1], edge[i].c1+dp[v][4]) - t);
ff = edge[i].c0 + dp[v][1] - t;
if(ff < f1){
f2 = f1;
f1 = ff;
matchf = v;
}else if(ff < f2){
f2 = ff;
}
ee = edge[i].c1 + dp[v][3] + edge[i].c0 - t;
if(ee < e1){
e2 = e1;
e1 = ee;
matche = v;
}else if(ee < e2){
e2 = ee;
}
}
}
}
if(matche != -1 && matchf != -1){
if(matchf != matche){
temp = f1 + e1;
}else{
temp = min(f1+e2, f2+e1);
}
}
dp[u][1] = dp[u][0] + temp1;
dp[u][3] = dp[u][2] + temp3;
dp[u][4] = dp[u][2] + min(temp4, temp);
dp[u][4] = min(dp[u][4], dp[u][3]);
}
int main(){
int i, u, v, c0, c1, edgeIndex, m, x; //edgeIndex用于构造树的时候指示边的下标
memset(FEdge, -1, sizeof(FEdge));
memset(isKey, 0, sizeof(isKey));
scanf("%d", &N);
edgeIndex = 0;
for(i = 1; i < N; i++){
scanf("%d%d%d%d", &u, &v, &c0, &c1);
AddEdge(u, v, c0, c1, edgeIndex);
edgeIndex++;
AddEdge(v, u, c0, c1, edgeIndex);
edgeIndex++;
}
scanf("%d", &m);
for(i = 0; i < m; i++){
scanf("%d", &x);
isKey[x] = 1;
}
DFS(1, -1);
printf("%lld\n", dp[1][4]);
return 0;
}