解題思路：

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