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意义也很容易想到：dp[i][j]表示以i为根节点，在i结点下选取j个城堡（包括自己）可以获得的最大收益

比较了几份代码，还是觉得左子树右兄弟的写法容易理解。

列出所有要考虑的情况：

p：某个子树的根结点，m：还可以攻打的城池数量

dp[p][m]所有可能的情况：

1.全部攻打p的兄弟结点

2.攻打p结点下的i个子结点，剩下m-i-1个分给p的兄弟结点

i从0考虑到m，这样就包括了所有可能的情况

#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
const int INF = 1<<29;
const int MAX = 250;
int N, M;
int dp[MAX][MAX];   //dp[i][j]表示i结点为根结点,在i结点下选择j个城堡获得的最大收益
vector<int> G[MAX];
int val[MAX];
int tree[MAX][2];   //左孩子右兄弟
int visit[MAX][MAX];

void init()
{
    memset(tree, -1, sizeof(tree));
    memset(val, 0, sizeof(val));
    memset(dp, 0, sizeof(dp));
    memset(visit, 0, sizeof(visit));
    for (int i = 0; i <= N; i++)
        G[i].clear();
}

void extree()
{
    for (int i = 0; i <= N; i++)
    {
        int len = G[i].size();
        for (int j = 0; j < len; j++)
        {
            if (j == 0)
                tree[i][0] = G[i][j];   //tree[i][0]是结点i的儿子结点
            else
                tree[G[i][j-1]][1] = G[i][j];   //ree[G[i][j-1]][1]是结点G[i][j-1]的兄弟结点
        }
    }
}

//p结点下攻克m座城堡的价值
void dfs(int p, int m)
{
    if (visit[p][m])   //没有标记位会TLE
        return;
    visit[p][m] = 1;
    if (p == -1 || m <= 0)
        return;
    dfs(tree[p][1], m);
    dp[p][m] = max(dp[p][m], dp[tree[p][1]][m]);

    for (int i = 0; i <= m - 1; i++)//p结点占用1个
    {
        dfs(tree[p][1], i); //兄弟结点取i个
        dfs(tree[p][0], m - 1 - i); //儿子结点取(m-1-i)个
        dp[p][m] = max(dp[p][m], dp[tree[p][0]][m-1-i] + dp[tree[p][1]][i] + val[p]);
    }
}

int main()
{
    while ((cin >> N >> M) && N && M)
    {
        init();
        for (int i = 1; i <= N; i++)
        {
            int a, b;
            cin >> a >> b;
            G[a].push_back(i);
            val[i] = b;
        }
        extree();
        dfs(0, M + 1);
        cout << dp[0][M+1] << endl;
    }

    return 0;
}