树形背包基础题

hdu1561

树形背包入门

代码是vector型邻接表，用数组的更好

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
vector<int>list[224];
int dp[224][224];
int value[224];
void DFS( int n ,int M )//M代表攻击该节点时还剩多少次 
{
    int len = list[n].size();
    dp[n][1] = value[n];// 攻击该节点能够得到的财富值
    for( int i = 0 ; i < len ; i++ )//继续攻击该节点下的子节点 
    {
        if( M > 1 )
        DFS( list[n][i] ,M -1 );
        for( int j = M ; j >= 1 ; j-- )// 孩子节点攻击的次数
        {
            int v = j + 1;
            for( int k = 1; k < v ; k++ )// 从孩子节点中找攻击J次的最优值 
            {
                if( dp[n][v] < dp[n][v-k] + dp[list[n][i]][k] )
                    dp[n][v] = dp[n][v-k] + dp[list[n][i]][k];
            }    
        }    
    }
}
int main( )
{
    int  n ,m ,start,end;
    while( scanf( "%d%d",&n ,&m ),n||m )
    {
        memset( dp , 0 , sizeof( dp ) );
        memset( value , 0 , sizeof( value ) );
        for( int i = 0 ; i <= n ; i++ )
        {
             list[i].clear( );
        }
        for( int i = 1 ; i <= n ; i++ )
        {
            scanf( "%d%d",&start , &value[i] );
            list[start].push_back( i );
        }
       DFS( 0 , m+1 );
//       printf( "afsa" );
       printf( "%d\n",dp[0][m+1] );
    }
    return 0;    
}

hdu 4169

树形背包，要求两个所取的节点不相邻，不要求所谓的约束关系了，用一个一维的数组dp[k]表示背包容量即可

要求不相邻的话，读入一个节点时只把它用来更新当前dp[k]，不参与相邻节点和该点的状态转移就好了~（我是这么理解的，，）

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

vector<int>son[150005];

int dp[305],K,N,w[150005];
const int max_int=10000000;
int dfs(int u)
{
    int t=0,cur[305];
    for (int i=1; i<=K; ++i)
        dp[i]=cur[i]=-max_int;
    dp[0]=cur[0]=0;//开层数个一维数组，节省空间了
    
    int size=son[u].size();//该点有几个儿子
    for (int i=0; i<size; ++i)
    {
        int now=dfs(son[u][i]);
        for (int j=t; j>=0; --j)//该点子树中取多少个点
            
            for (int k=1; j+k<=K && k<=now; ++k)
                cur[j+k]=max(cur[j+k],cur[j]+dp[k]);
        t+=now;
    }
    
    if (!size)
        t=1;
        
    cur[1]=max(cur[1],w[u]);//只有一个节点时的最大值，取该节点或之前遍历过的部分的一个节点中的最大值
    //如果取了这个点，
    for (int i=0; i<=K; ++i)
        dp[i]=cur[i];
    return t;//t是该子树的节点个数
}
int main()
{
    int i,j,root;
    while (scanf("%d%d",&N,&K)!=EOF)
    {
        for (i=0; i<=N; ++i)
            son[i].clear();
        int r;
        for (i=1; i<=N; ++i)
        {
            scanf("%d%d",&r,&w[i]);
            if (!r)
                root=i;
            else
                son[r].push_back(i);//vector型邻接表
        }
        
        dfs(root);
        
        if (dp[K]==-max_int)//取了的元素个数
            puts("impossible");
        else
            printf("%d\n",dp[K]);
    }
    return 0;
}