Matrix:(cin,cout标程要运行2s,scanf,printf 1s)
对于有n个结点的树,容易证明删除任意的k (k<=n-1)条边都能将原树切成k+1个部分。按照题意至少需要将原树划分成d个部分(此时每部分中都包含一个危险的点),删除的边数为d-1。
贪心算法:类似kruskal最小生成树的过程,不过此处将边按权值从大到小排列,每次将边加进来时要判断是否会使两个危险的点连通,是的话这条边就是需要被删除的,否则将它加到树上。
树形dp:以任意一个点作为根生成树,对于每个结点保存两个值
dp[u][0]: 与u连通的子孙结点中没有危险结点时需要删除的最小边权值,若u为危险结点,则该值为无穷大。
dp[u][1]:与u连通的子孙结点中没有危险结点时需要删除的最小边权值。
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<memory.h>
using namespace std;
const int INF=0x3ffffff;
const int maxn=100002;
int n,k,NE,t;
int head[maxn],vis[maxn],cost[maxn];
__int64 sum;
vector<int>dp[maxn];
struct node
{
int u,v,val,next;
} Edge[maxn];
void addEdge(int u,int v,int val)
{
Edge[NE].u=u;
Edge[NE].v=v;
Edge[NE].val=val;
Edge[NE].next=head[u];
head[u]=NE++;
}
void dfs(int u)
{
int i,j;
for(i=head[u]; i!=-1; i=Edge[i].next)
{
int r=Edge[i].v;
//if(u==r) continue;
dfs(r);
if(vis[r])
{
dp[u].push_back(min(Edge[i].val,cost[r]));
}
}
int len=dp[u].size();
if(len==0)
{
cost[u]=INF;
return ;
}
sort(dp[u].begin(),dp[u].end());
for(i=0;i<len-1;i++)
{
sum+=dp[u][i];
}
if(vis[u])
{
sum+=dp[u][i];
cost[u]=INF;
}
else
{
vis[u]=1;
cost[u]=dp[u][i];
}
}
int main()
{
scanf("%d",&t);
int i,j,a,b,val,m;
while(t--)
{
NE=0;sum=0;
scanf("%d%d",&n,&k);
memset(head,-1,sizeof(head));
memset(vis,0,sizeof(vis));
for(i=0; i<n; i++)
{
dp[i].clear();
}
//memset(dp,0,sizeof(dp));
memset(cost,0,sizeof(cost));
for(i=1; i<n; i++)
{
scanf("%d%d%d",&a,&b,&val);
if(a>b) swap(a,b);
addEdge(a,b,val);
}
for(j=1; j<=k; j++)
{
scanf("%d",&m);
// m++;
vis[m]=1;
}
dfs(0);
printf("%I64d\n",sum);//long long 就报错,囧~~~
}
return 0;
}