HDU 1561The more, The Better（树形DP）

HDU 1561  The more, The Better

题目大意就不说了

直接DP[i][j]表示i为跟节点的子树上攻克j个城堡的所能获得的最多宝物的数量

DP[fa][j] = MAX{DP[fa][i-k] + DP[child][k]};

首先一个问题就是说如果子树u下的任意子节点被选择了，那么u是一定需要选择的，怎么在DP时保证准确性，其实这个很好解决，我们在计算时是需要枚举k（子节点的攻克数量）的，那么我们迫使k<j就可以了，这样的话DP[fa][j] 就不会被子节点的DP[child][j]更新掉保证了他的父节点一定在被选择的里面

另外一个问题就是如果枚举j时是从小到达枚举，那么DP[fa][j]很可能已经被当前的child更新过了，那么在计算DP[fa][j+1]或者以后时，很可能有会被放入同一个child，导致当前的child被选择了多次，所以我们需要逆序枚举j(k的顺序无关紧要了)

最后的结果就是个棵树上同样取DP值，只是一颗完整的树上可以一个也不取了

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF ((LL)100000000000000000)
#define inf (-((LL)1<<40))
#define lson k<<1, L, mid
#define rson k<<1|1, mid+1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FOPENIN(IN) freopen(IN, "r", stdin)
#define FOPENOUT(OUT) freopen(OUT, "w", stdout)
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 255;
const int MAXM = 110000;
const double eps = 1e-12;
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};

int N, M;
int G[MAXN][MAXN], vis[MAXN], num[MAXN];
int DP[MAXN][MAXN], D[MAXN];

void DFS(int u)
{
    vis[u] = 1;
    DP[u][1] = num[u];
    for(int i=1;i<=N;i++)  if(G[u][i])
    {
        if(!vis[i]) DFS(i);
        for(int j=M;j>0;j--)//这里为了保证是先从父节点更新，需要逆序
            for(int k=0;k<j;k++)//k<j保证父节点不会被更新掉
                DP[u][j] = MAX(DP[u][j], DP[u][j-k] + DP[i][k]);
    }
}

int main()
{
    //FOPENIN("in.txt");
    while(~scanf("%d %d", &N, &M) &&( N||M))
    {
        int a;mem0(G);mem0(D);mem0(vis);mem0(DP);
        for(int i=1;i<=N;i++) {
            scanf("%d %d", &a, &num[i]);
            if(a != 0)G[a][i] = 1;
            else D[i] = 1;
        }
        for(int i=1;i<=N;i++) if(!vis[i]){
            DFS(i);
            if(D[i]) for(int j=M;j>=0;j--)//同样需要逆序，可以取到0
            {
                for(int k=0;k<=j;k++)
                    DP[0][j] = MAX(DP[0][j], DP[0][j-k] + DP[i][k]);
            }
        }
        printf("%d
", DP[0][M]);

    }
    return 0;
}