UVALive - 4015 Caves 树形DP

转自；

http://blog.csdn.net/l123012013048/article/details/44539895

why:

显然在状态表示中不可以有R（距离）因为太大了。。

所以就只能有节点个数（500）（也同时是题目要求的） 和出发的（节点），

然后，发现到某一个节点的时候有两个决策，，

从这个v回来，不回来，所以有 第三个维度0，1，

，如果是从这个v回来的，那么其他的走的节点就不用回来，

如果是从这个v出去了就不回来，那么其他节点就要回来。。

那么最优子结构就是     子节点的是最短的路径，然后通过遍历， 使得自己也是最优的。。

#include<bits/stdc++.h>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a));
#define sf scanf
#define pf printf
#define bug1 printf("bug1\n");
#define N 505
#define inf 0x3f3f3f3f
int n;

vector<int>tree[N];

int dis[N][N];
int dp[N][N][2];
int son[N];
int dfs(int cur){
    son[cur]=1;
    int size=tree[cur].size();
    for(int i=0;i<size;++i){
        son[cur]+=dfs(tree[cur][i]);
    }
    dp[cur][1][0]=dp[cur][1][1]=0;
    for(int i=0;i<size;++i){
        int v=tree[cur][i];
        int len=dis[cur][v];
        for(int j=son[cur];j>=1;j--){
            for(int k=1;k<=son[v]&&k<j;++k){
                dp[cur][j][1]=min(dp[cur][j][1],dp[cur][j-k][1]+2*len+dp[v][k][1]);
                dp[cur][j][0]=min(dp[cur][j][0],dp[cur][j-k][1]+dp[v][k][0]+len);//表示有k个节点是从v这里走出去的，并且是从其他地方走回到cur的，
                dp[cur][j][0]=min(dp[cur][j][0],dp[cur][j-k][0]+dp[v][k][1]+2*len);//2*len表示会回来到cur，然后走到其他地方没有回来到cur
            }
        }
    }
    return son[cur];
}
int main(){
    int cas=0;
    while(~sf("%d",&n)&&n){
        mem(dp,inf);mem(son,0);
        for(int i=0;i<=n;++i)tree[i].clear();
        for(int i=1;i<=n-1;++i){
            int x,y;sf("%d%d",&x,&y);
            int len;sf("%d",&len);
            tree[y].push_back(x);
            dis[y][x]=len;
        }
        dfs(0);
        int cnt;sf("%d",&cnt);
        pf("Case %d:\n",++cas);
        while(cnt--){
            int maxx;sf("%d",&maxx);
            for(int i=n;i>=0;i--){
                if(dp[0][i][0]<=maxx){
                    pf("%d\n",i);
                    break;
                }
            }
        }
    }
}