NKOJ1469 通向自由的钥匙

P1469通向自由的钥匙

时间限制 : 10000 MS   空间限制 : 65536 KB

问题描述

通向自由的钥匙被放n个房间里，这n个房间由n-1条走廊连接。但是每个房间里都有特别 的保护魔法，在它的作用下，我无法通过这个房间，也无法取得其中的钥匙。虽然我可以通过消耗能量来破坏房间里的魔法，但是我的能量是有限的。那么，如果我 最先站在1号房间（1号房间的保护魔法依然是有效的，也就是，如果不耗费能量，我无法通过1号房间，也无法取得房间中的钥匙），如果我拥有的能量为P，我 最多能取得多少钥匙？

输入格式

第一行包含两个非负整数，第一个为N，第二个为P。
接下来n行，按1~n的顺序描述了每个房间。第i+1行包含两个非负整数cost和keys，分别为第i件房取消魔法需要耗费的能量和房间内钥匙的数量。
接下来n-1行，每行两个非负整数x,y，表示x号房间和y号是连通的。

输出格式

一行一个整数，表示取得钥匙的最大值。

样例输入

5 5
1 2
1 1
1 1
2 3
3 4
1 2
1 3
2 4
2 5

样例输出

7

提示

对于20%的测试数据，有n<=20
对于30%的测试数据，有n<=30
对于所有测试数据，有p,n<=100, cost <= 32767, keys<= 32767

【题解】

多叉树转二叉树，左儿子右兄弟表示法

各种傻逼错各种卡

“将树转化为孩子兄弟表示法，由于根的左孩子还是它的孩子，右孩子是它的兄弟，因此：
树根获取资源，则左右孩子均可获取资源
树根不获取资源，则左孩子不能获取资源，右孩子可获取资源。
设f(i,j)表示以i为根结点的二叉树分配分配j的能量所获得的最多钥匙数，则有

”

——朱全民

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) > (b) ? (a) : (b))

 inline void read(int &x)
 {
     x = ;char ch = getchar(), c = ch;
     while(ch < '' || ch > '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')x = -x;
 }

 const int INF = 0x3f3f3f3f;
 const int MAXN =  + ;
 const int MAXP =  + ;

 int n,p,dp[MAXN][MAXP],cost[MAXN],key[MAXN];

 struct Edge
 {
     int u,v,next;
     Edge(int _u, int _v, int _next){u = _u;v = _v;next = _next;}
     Edge(){}
 }edge[MAXN];

 int head[MAXN],cnt;

 void insert(int a, int b)
 {
     edge[++cnt] = Edge(a,b,head[a]);
     head[a] = cnt;
 }

 struct Node
 {
     int l, r;
 }node[MAXN];

 int b[MAXN];

 void dfs(int u)
 {
     b[u] = ;
     int kid1 = , kid2 = ;
     for(register int pos = head[u];pos;pos = edge[pos].next)
     {
         int v = edge[pos].v;
         if(!b[v])
         {
             if(!kid1)
             {
                 kid1 = v;
                 node[u].l = v;
             }
             else node[kid1].r = v, kid1 = v;
             dfs(v);
         }
     }
 }

 int bb[MAXN];

 void DP(int u)
 {
     if(!u)return;
     bb[u] = ;
     if(!bb[node[u].l])DP(node[u].l);
     if(!bb[node[u].r])DP(node[u].r);
     for(register int i = ;i <= p;++ i)
     {
         for(register int j = ;j <= p;++ j)
             if(i - cost[u] - j >= )dp[u][i] = max(dp[node[u].l][j] + key[u] + dp[node[u].r][i - cost[u] - j], dp[u][i]);
             else dp[u][i] = max(dp[node[u].r][i], dp[u][i]);
     }
 }

 int main()
 {
     read(n), read(p);
     register int tmp1, tmp2;
     for(register int i = ;i <= n;++ i) read(cost[i]), read(key[i]);
     for(register int i = ;i < n;++ i)
     {
         read(tmp1), read(tmp2);
         insert(tmp1, tmp2);
         insert(tmp2, tmp1);
     }
     dfs();
     DP();
     printf("%d", dp[][p]);
     return ;
 }

NKOJ1469 通向自由的钥匙