The more, The Better(hdu1561)

The more, The Better

Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7867    Accepted Submission(s): 4616

Problem Description

ACboy很喜欢玩一种战略游戏，在一个地图上，有N座城堡，每座城堡都有一定的宝物，在每次游戏中ACboy允许攻克M个城堡并获得里面的宝物。但由于地理位置原因，有些城堡不能直接攻克，要攻克这些城堡必须先攻克其他某一个特定的城堡。你能帮ACboy算出要获得尽量多的宝物应该攻克哪M个城堡吗？

Input

每个测试实例首先包括2个整数，N,M.(1 <= M <= N <= 200);在接下来的N行里，每行包括2个整数，a,b. 在第 i 行，a 代表要攻克第 i 个城堡必须先攻克第 a 个城堡，如果 a = 0 则代表可以直接攻克第 i 个城堡。b 代表第 i 个城堡的宝物数量, b >= 0。当N = 0, M = 0输入结束。

Output

对于每个测试实例，输出一个整数，代表ACboy攻克M个城堡所获得的最多宝物的数量。

Sample Input

3 2
0 1
0 2
0 3
7 4
2 2
0 1
0 4
2 1
7 1
7 6
2 2
0 0

Sample Output

5

13

思路：树形dp+01背包;

首先这个题中是无环的。

• 7 4
• 2 2
• 0 1
• 0 4
• 2 1
• 7 1
• 7 6
• 2 2
• 这组数据所建的图：
•                   [0]
•                  /         
•             [2]          [3]
•          /    |      
•    [1]   [4]   [7]
•                   /     
•                 [5]  [6]

0为根节点，我们只能先取上面的根节点才能取下面的子节点，dp[i][j]表是以i为当前根节点的子树所取的点为j的最大值。先给dp[i][1] = val[i]，表示当前节点必须选，其他dp[i][j] = -1,所以要更新当前节点必然包含当前的根节点，这样保证了先后性，状态转移方程看代码（01背包）复杂度（n^3）。

#include<iostream>
#include<string.h>
#include<algorithm>
#include<queue>
#include<math.h>
#include<stdlib.h>
#include<stack>
#include<stdio.h>
#include<ctype.h>
#include<map>
#include<vector>
#include<map>
using namespace std;
typedef long long LL;
int dp[300][300];
int cnt[300];
int val[300];
bool vis[300];
int s[300];
vector<int>vec[1000];
vector<int>topu[1000];
queue<int>que;
void Init()
{
    while(!que.empty())
        que.pop();
    for(int i = 0; i < 300; i++)
        vec[i].clear(),topu[i].clear();
    memset(dp,-1,sizeof(dp));
    memset(cnt,0,sizeof(cnt));
    memset(val,0,sizeof(val));
    memset(vis,0,sizeof(vis));
    memset(s,0,sizeof(s));
}
void dfs(int n,int m);
int main(void)
{
    int n,m;
    while(scanf("%d %d",&n,&m),n!=0&&m!=0)
    {
        Init();
        for(int i = 1; i <= n; i++)
        {
            int a,b;
            scanf("%d %d",&a,&val[i]);
            vec[a].push_back(i);
            dp[i][1] = val[i];
            dp[i][0] = 0;
        }
        dp[0][1] = 0;
        dfs(0,m+1);
        printf("%d
",dp[0][m+1]);
    }
    return 0;
}
void dfs(int n,int m)
{
    for(int i = 0; i < vec[n].size(); i++)
    {
        int id = vec[n][i];
        dfs(id,m);
        for(int j = m; j >= 2; j--)
        {
            for(int ss = 1; ss <= j-1; ss++)
            {
                if(dp[id][j-ss]!=-1&&dp[n][ss]!=-1)
                    dp[n][j] = max(dp[n][j],dp[id][j-ss]+dp[n][ss]);
            }
        }
    }
}