hdu 3452 - Bonsai 最小割 树形dp

http://acm.hdu.edu.cn/showproblem.php?pid=3452

Problem Description

After being assaulted in the parking lot by Mr. Miyagi following the "All Valley Karate Tournament", John Kreese has come to you for assistance. Help John in his quest for justice by chopping off all the leaves from Mr. Miyagi's bonsai tree!
You are given an undirected tree (i.e., a connected graph with no cycles), where each edge (i.e., branch) has a nonnegative weight (i.e., thickness). One vertex of the tree has been designated the root of the tree.The remaining vertices of the tree each have unique paths to the root; non-root vertices which are not the successors of any other vertex on a path to the root are known as leaves.Determine the minimum weight set of edges that must be removed so that none of the leaves in the original tree are connected by some path to the root.

 

Input

The input file will contain multiple test cases. Each test case will begin with a line containing a pair of integers n (where 1 <= n <= 1000) and r (where r ∈ ｛1,……, n｝) indicating the number of vertices in the tree and the index of the root vertex, respectively. The next n-1 lines each contain three integers u_i v_i w_i (where u_i, v_i ∈ {1,……, n} and 0 <= w_i <= 1000) indicating that vertex u_i is connected to vertex v_i by an undirected edge with weight w_i. The input file will not contain duplicate edges. The end-of-file is denoted by a single line containing "0 0".

 

Output

For each input test case, print a single integer indicating the minimum total weight of edges that must be deleted in order to ensure that there exists no path from one of the original leaves to the root.

 

Sample Input

15 15
1 2 1
2 3 2
2 5 3
5 6 7
4 6 5
6 7 4
5 15 6
15 10 11
10 13 5
13 14 4
12 13 3
9 10 8
8 9 2
9 11 3
0 0

 

Sample Output

16

http://blog.csdn.net/xianxingwuguan1/article/details/20869207

给定一棵树，求最小花费使得根节点与叶子节点断开。

两种思路：树形dp，dp[u]表示切断以u为子树的代价，

1. typedef long long ll;  
2. const int maxn=2020;  
3. int head[maxn],tol;  
4. struct Edge{  
5.     int next,to,val;  
6. }edge[10*maxn];  
7. void add(int u,int v,int w){  
8.     edge[tol].to=v;  
9.     edge[tol].next=head[u];  
10.     edge[tol].val=w;  
11.     head[u]=tol++;  
12. }  
13. int dp[maxn];  
14. void dfs(int u,int fa){  
15.     int d=0;  
16.     for(int i=head[u];i!=-1;i=edge[i].next){  
17.         int v=edge[i].to;  
18.         if(v==fa)continue;  
19.         dfs(v,u);  
20.         d+=min(dp[v],edge[i].val);  
21.     }  
22.     if(d)dp[u]=d;  
23. }  
24. int main()  
25. {  
26.      //freopen("data.in","r",stdin);  
27.      //freopen("data.out","w",stdout);  
28.      int n,r;  
29.      while(~scanf("%d%d",&n,&r)&&(n||r)){  
30.          memset(head,-1,sizeof(head));tol=0;  
31.          for(int i=1;i<n;i++){  
32.              int j,k,m;  
33.              scanf("%d%d%d",&j,&k,&m);  
34.              add(j,k,m);  
35.              add(k,j,m);  
36.          }  
37.          memset(dp,0x3f,sizeof(dp));  
38.          dfs(r,-1);  
39.          if(n==1)puts("0");  
40.          else cout<<dp[r]<<endl;  
41.      }  
42.      return 0;  
43. }

第二种思路：最小割，源点向根节点连边，容量inf，叶节点向汇点连边，容量inf，把剩下的边连双向，根据最小割最大流定理，最大流等于最小割。

1. typedef long long ll;  
2. const int maxn=2010;  
3. const int maxm=1002000;  
4. struct Edge{  
5.     int next,to,cap;  
6.     Edge(){};  
7.     Edge(int _next,int _to,int _cap){  
8.         next=_next;to=_to;cap=_cap;  
9.     }  
10. }edge[maxm];  
11. int head[maxn],tol,dep[maxn],gap[maxn];  
12. void addedge(int u,int v,int flow){  
13.     edge[tol]=Edge(head[u],v,flow);head[u]=tol++;  
14.     edge[tol]=Edge(head[v],u,0);head[v]=tol++;  
15. }  
16. void bfs(int start,int end){  
17.     memset(dep,-1,sizeof(dep));  
18.     memset(gap,0,sizeof(gap));  
19.     gap[0]++;int front=0,rear=0,Q[maxn];  
20.     dep[end]=0;Q[rear++]=end;  
21.     while(front!=rear){  
22.         int u=Q[front++];  
23.         for(int i=head[u];i!=-1;i=edge[i].next){  
24.             int v=edge[i].to;if(dep[v]==-1)  
25.                 Q[rear++]=v,dep[v]=dep[u]+1,gap[dep[v]]++;  
26.         }  
27.     }  
28. }  
29. int sap(int s,int t,int N){  
30.     int res=0;bfs(s,t);  
31.     int cur[maxn],S[maxn],top=0,u=s,i;  
32.     memcpy(cur,head,sizeof(head));  
33.     while(dep[s]<N){  
34.         if(u==t){  
35.             int temp=INF,id;  
36.             for( i=0;i<top;i++)  
37.                if(temp>edge[S[i]].cap)  
38.                    temp=edge[S[i]].cap,id=i;  
39.             for( i=0;i<top;i++)  
40.                   edge[S[i]].cap-=temp,edge[S[i]^1].cap+=temp;  
41.             res+=temp;top=id;u=edge[S[top]^1].to;  
42.         }  
43.         if(u!=t&&gap[dep[u]-1]==0)break;  
44.         for( i=cur[u];i!=-1;i=edge[i].next)  
45.             if(edge[i].cap&&dep[u]==dep[edge[i].to]+1)break;  
46.         if(i!=-1)cur[u]=i,S[top++]=i,u=edge[i].to;  
47.         else{  
48.             int MIN=N;  
49.             for( i=head[u];i!=-1;i=edge[i].next)  
50.                 if(edge[i].cap&&MIN>dep[edge[i].to])  
51.                     MIN=dep[edge[i].to],cur[u]=i;  
52.             --gap[dep[u]];++gap[dep[u]=MIN+1];  
53.             if(u!=s)u=edge[S[--top]^1].to;  
54.         }  
55.     }  
56.     return res;  
57. }  
58. int in[maxn];  
59. int main()  
60. {  
61.      //freopen("data.in","r",stdin);  
62.      //freopen("data.out","w",stdout);  
63.      int n,r;  
64.      while(~scanf("%d%d",&n,&r)&&(n||r)){  
65.          memset(head,-1,sizeof(head));tol=0;  
66.          int sum=0;  
67.          memset(in,0,sizeof(in));  
68.          for(int i=1;i<n;i++){  
69.              int j,k,m;  
70.              scanf("%d%d%d",&j,&k,&m);  
71.              addedge(j,k,m);  
72.              addedge(k,j,m);  
73.              sum+=m;in[j]++;in[k]++;  
74.          }  
75.         // for(int i=1;i<=n;i++)cout<<in[i]<<" ";cout<<endl;  
76.          for(int i=1;i<=n;i++){  
77.              if(i==r)addedge(0,r,INF);  
78.              else if(in[i]==1)addedge(i,n+1,INF);  
79.          }  
80.          int ans=sap(0,n+1,3*n);  
81.          cout<<ans<<endl;  
82.      }  
83.      return 0;  
84. }