bzoj 1017 tree dp

这道题几经波折啊。

最开始和vfleaking一样，把题意理解错了，认为一个装备可能被多个装备依赖，然后想不出来，去看题解。

发现自己理解错了题意，自己想想，其实也不难想到dp[i][j][k]表示“i号节点代表的子树，用掉j的钱，给父亲预留k个自己（但还是父亲付钱）”的状态，写出来交上去就是T，

开始以为是常数问题，优化半天还是T，看了他人AC代码，才发现自己算法有一定问题:重复计算了很多东西。

树形动规，一般在大的树规下，每个节点还会对儿子们来一次”资源分配“,一般是用背包解决，这道题也是这样，但又有一点不一样，就是我们也要给该子树的根节点本身分配资源，

我就是这儿重复计算了，对于所有儿子的同一k，我算了多次。

 /**************************************************************
     Problem: 1017
     User: idy002
     Language: C++
     Result: Accepted
     Time:16524 ms
     Memory:48316 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #define max(a,b) ((a)>(b)?(a):(b))
 #define min(a,b) ((a)<(b)?(a):(b))
 #define maxn 55
 #define maxm 2010
 #define maxl 110
 #define oo 0x3f3f3f3f
 using namespace std;

 int n, m;
 int indgr[maxn];
 int power[maxn], cost[maxn], limit[maxn];
 int head[maxn], next[maxn], dest[maxn], wght[maxn], tot;

 int dp[maxn][maxm][maxl];
 int ep[maxm];

 void insert( int a, int b, int w ) {
     tot++;
     wght[tot] = w;
     dest[tot] = b;
     next[tot] = head[a];
     head[a] = tot;
 }
 void dfs( int i ) {
     if( !head[i] ) return;
     cost[i] = ;
     limit[i] = oo;

     for( int t=head[i]; t; t=next[t] ) {
         int s = dest[t], w = wght[t];
         dfs( s );
         cost[i] += cost[s]*w;
         limit[i] = min( limit[i], limit[s]/w );
     }
 }

 void dodp( int i ) {
     if( !head[i] ) {
         for( int l=; l<=limit[i]; l++ )
             for( int k=l; k>=; k-- ) {
                 int self = (l-k);
                 int j = self*cost[i];
                 if( j>m ) break;
                 dp[i][j][k] = self*power[i];
             }
         return;
     }
     for( int t=head[i]; t; t=next[t] )
         dodp( dest[t] );
     for( int l=; l<=limit[i]; l++ ) {
         for( int j=; j<=m; j++ ) ep[j]=;
         for( int t=head[i]; t; t=next[t] ) {
             int v = dest[t], w = wght[t];
             int vl = l*w;
             for( int j=m; j>=; j-- )
                 for( int jj=; jj<=j; jj++ )
                     ep[j] = max( ep[j], ep[j-jj]+dp[v][jj][vl] );
         }
         for( int j=; j<=m; j++ )
             for( int k=l; k>=; k-- ) {
                 int self = l-k;
                 int remain =  j- self*cost[i];
                 if( remain< ) break;
                 dp[i][j][k] = max( dp[i][j][k], ep[remain]+self*power[i] );
             }
     }
 }

 int main() {
     scanf( "%d%d", &n, &m );
     for( int i=; i<=n; i++ ) {
         char type[];
         scanf( "%d%s", power+i, type );
         if( type[]=='A' ) {
             int cnt;
             scanf( "%d", &cnt );
             for( int t=,c,w; t<=cnt; t++ ) {
                 scanf( "%d%d", &c, &w );
                 insert( i, c, w );
                 indgr[c]++;
             }
         } else
             scanf( "%d%d", cost+i, limit+i );
     }
     int root = ;
     for( int i=; i<=n; i++ )
         if( indgr[i]== ) {
             root = i;
             break;
         }
     memset( dp, , sizeof(dp) );
     dfs(root);
     dodp(root);
     int ans = ;
     for( int j=; j<=m; j++ ) ans = max( ans, dp[root][j][] );
     printf( "%d\n", ans );
 }