hihocoder #1035 : 自驾旅行 III

题目描述：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;
}