hdu 3586 树状dp

题意：

给出一棵树，和每条边的cost值，设置一个界限，要求切断所有叶子结点，切断的边的cost不能超过界限值，并且切断的边的总和不能超过m,求出这个最小界限值。

解题思路:

很明显的一道树型DP，DP[v],表示切断根结点的v的子树的最小花费，那么这个界限怎么处理呢，由于界限值范围要比总和m小得多，才1－1000，可以用二分枚举，这样在选择切边时可以根据这个枚举值进行判断处理。每个结点v，设其儿子结点为x1,x2,x3...则DP[v] = Min{DP[x1],Node[x1].cost} + Min{DP[x2], Node[x2].cost} + ...，当然，要判断Node[x].cost是否小于枚举的界限，Node[x].cost表示边（v,x）的cost值。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<memory.h>
using namespace std;
int dp[1002],n,m,NE,mid;
int head[1002],vis[1002];
const int INF=1000001;
struct node
{
    int u,v,val,next;
} Edge[2002];
void addEdge(int u,int v,int w)
{
    Edge[NE].u=u,Edge[NE].v=v,Edge[NE].next=head[u];
    Edge[NE].val=w;
    head[u]=NE++;
}
int dfs(int u,int fa)
{
    int i,sum=0;
    vis[u]=1;
    for(i=head[u]; i!=-1; i=Edge[i].next)
    {
        int r=Edge[i].v;
        if(fa==r) continue;
        int rr=dfs(r,u);
        if(rr>Edge[i].val&&Edge[i].val<=mid)
        {
            rr=Edge[i].val;
        }
        sum+=rr;
    }
    if(!sum)return INF;
    return sum;
}
int main()
{
    while(cin>>n>>m,(n||m))
    {
        NE=0;
        int i,j,k,a,b,w,ans=INF;
        int l=1002,r=0;
        memset(vis,0,sizeof(vis));
        memset(head,-1,sizeof(head));
        for(i=1; i<n; i++)
        {
            cin>>a>>b>>w;
            addEdge(a,b,w);
            addEdge(b,a,w);
            l=min(l,w);
            r=max(r,w);
        }
        while(l<=r)
        {
            mid=(l+r)>>1;
            if(dfs(1,0)<=m)
            {
                ans=min(ans,mid);
                r=mid-1;
            }
            else l=mid+1;
        }
        if(ans>=INF)cout<<-1<<endl;
        else cout<<ans<<endl;
    }
    return 0;
}