题目大意:
就是现在给出一棵树节点数不超过10万, 然后给出K个点表示这K个点需要被隔开, 树上的每条边都有一个权值, 现在为了将这K个点隔开(没有边连通)需要删除一些使得删除的边的权值和最小
大致思路:
用dp[u][0]表示结点u及其子树部分没有能向上连通的要隔离的点需要的最小花费, 用dp[u][1]表示结点u及其子树中有1个点会向上连通时需要的最小花费
那么就是一个简单的树形DP了....最近树形DP写得有点多....一发AC了= =
代码如下:
Result : Accepted Memory : 9404 KB Time : 280 ms
/*
* Author: Gatevin
* Created Time: 2015/7/31 16:44:32
* File Name: Sakura_Chiyo.cpp
*/
#pragma comment(linker, "/STACK:16777216")
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define maxn 100010
const lint inf = 1e12;
vector <int> G[maxn];
vector <int> w[maxn];
int N, K;
lint dp[maxn][2];
bool del[maxn];
void dfs(int now, int fa)
{
int nex;
dp[now][0] = dp[now][1] = inf;
for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
dfs(nex, now);
if(G[now].size() == 1 && fa != -1)
{
if(del[now]) dp[now][1] = 0;
else dp[now][0] = 0;
return;
}
lint all = 0;
for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
all += min(dp[nex][0], dp[nex][1] + w[now][i]);
if(!del[now])//now不删
{
dp[now][0] = all;
for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
dp[now][1] = min(dp[now][1], dp[now][0] + - min(dp[nex][0], dp[nex][1] + w[now][i]) + dp[nex][1]);
}
else
{
dp[now][1] = all;
}
return;
}
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
scanf("%d %d", &N, &K);
for(int i = 0; i <= N + 1; i++)
{
G[i].clear();
w[i].clear();
}
int x, y, z;
for(int i = 1; i < N; i++)
{
scanf("%d %d %d", &x, &y, &z);
G[x].push_back(y);
w[x].push_back(z);
G[y].push_back(x);
w[y].push_back(z);
}
memset(del, 0, sizeof(del));
while(K--)
{
scanf("%d", &x);
del[x] = 1;
}
dfs(0, -1);
printf("%I64d\n", min(dp[0][0], dp[0][1]));
}
return 0;
}