UVA 1407 Caves (树形dp)

题意：

有一颗树，树上的每条边有一个距离，一个人最多只能走W的路程，问这个人能走的最多的节点数是多少。每个测试实例有q个询问，每个询问给出一个W问对应能走的对打节点数。

题解：

这题显然不能用路程作为背包，反过来，用点数作为背包，路程作为价值，尽量让价值最小，首先用树形dp预处理出对应的最小价值，然后根据每个询问从节点大到小查找最大的节点数满足价值<=W。

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
#include<map>
#include<set>
#define B(x) (1<<(x))
using namespace std;
typedef long long ll;
void cmax(int& a,int b){ if(b>a)a=b; }
void cmin(int& a,int b){ if(b<a)a=b; }
void cmax(ll& a,ll b){ if(b>a)a=b; }
void cmin(ll& a,ll b){ if(b<a)a=b; }
void add(int& a,int b,int mod){ a=(a+b)%mod; }
void add(ll& a,ll b,ll mod){ a=(a+b)%mod; }
const int oo=0x3f3f3f3f;
const int MOD=100007;
const int maxn=505;
const int maxm=10000005;
struct EDGE{
    int v,w,next;
}E[maxn<<1];
int head[maxn],tol;
int W;
ll dp[maxn][maxn][2];
int son[maxn];

void Init(){
    memset(head,-1,sizeof head);
    tol=0;
}

void add_edge(int u,int v,int w){
    E[tol].v=v;
    E[tol].w=w;
    E[tol].next=head[u];
    head[u]=tol++;
}

int dfs(int u,int pre){
    son[u]=1;
    for(int i=head[u];i!=-1;i=E[i].next){
        int v=E[i].v;
        if(v==pre)continue;
        dfs(v,u);
        son[u]+=son[v];
    }
    return son[u];
}

void tree_dp(int u,int pre){

    for(int i=0;i<=son[u];i++)
        dp[u][i][0]=dp[u][i][1]=oo;
    dp[u][1][0]=dp[u][1][1]=0;
    for(int i=head[u];i!=-1;i=E[i].next){
        int v=E[i].v;
        if(v==pre)continue;
        tree_dp(v,u);
        for(int j=son[u];j>=1;j--){
            for(int k=1;k<j&&k<=son[v];k++){
                cmin(dp[u][j][0],dp[u][j-k][1]+dp[v][k][0]+E[i].w);
                cmin(dp[u][j][0],dp[u][j-k][0]+dp[v][k][1]+E[i].w*2);
                cmin(dp[u][j][1],dp[u][j-k][1]+dp[v][k][1]+E[i].w*2);
            }
        }
    }
}

int main(){
    //freopen("E:\\read.txt","r",stdin);
    int cas=1,n,u,v,d,q;
    while(scanf("%d",&n)!=EOF){
        if(n==0)break;
        Init();
        for(int i=1;i<=n-1;i++){
            scanf("%d %d %d",&u,&v,&d);
            add_edge(u,v,d);
            add_edge(v,u,d);
        }
        dfs(0,-1);
        tree_dp(0,-1);
        scanf("%d",&q);
        printf("Case %d:\n",cas++);
        while(q--){
            scanf("%d",&W);
            int ans=0,temp;
            for(int f=0;f<=1;f++){
                temp=0;
                for(int j=n;j>=0;j--){
                    if(dp[0][j][f]<=W){
                        temp=j;
                        break;
                    }
                }
                cmax(ans,temp);
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}