CDOJ 1136 邱老师玩游戏 树形01背包 (有依赖的背包问题)

点击打开链接

第一种思路：

建立森林，dp[i][k]表示森林中在第i颗树中选k个的最大价值 ， dp2[j]表示选j个的最大价值，对于每颗树，都更新一次。

转移方程：

dp[u][j] = max(dp[u][j],dp[u][j-k]+dp[v][k])；

dp2[j] = max(dp2[j],dp2[j-k]+dp[i][k])；

代码：

 

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
using namespace std;

const int maxn = 200+10;

vector<int> G[maxn];
int dp[maxn][maxn],dp2[maxn],a[maxn],va[maxn],n,m;

void dfs(int u){
    dp[u][1] = va[u];
    dp[u][0] = 0;
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i];
        dfs(v);
        for(int j=m; j>=2; j--)
            for(int k=0; k<j; k++) // 已经选了u  所以不能再儿子里选全部j个 k<j
                dp[u][j] = max(dp[u][j],dp[u][j-k]+dp[v][k]);
    }
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0 && m==0) break;
        memset(dp,0,sizeof(dp));
        memset(dp2,0,sizeof(dp2));
        for(int i=0;i<maxn;i++)
            G[i].clear();
        memset(a,0,sizeof(a));
        for(int i=1; i<=n; i++){
            cin >> a[i] >> va[i];
            if(a[i]!=0)
                G[a[i]].push_back(i); // 形成森林
        }

        for(int i=1; i<=n; i++){
            if(a[i] == 0)
                dfs(i); // 每一颗树都跑一遍01背包 dp[i][k]表示在第i颗树中选k个的最大价值
        }

        for(int i=1; i<=n; i++){
            if(a[i] == 0){
                for(int j=m; j>=0; j--)
                    for(int k=0; k<=j; k++)
                        dp2[j] = max(dp2[j],dp2[j-k]+dp[i][k]); // dp2[j]表示选j个的最大价值，对于每颗树，都更新一次
            }
        }

        cout << dp2[m] << endl;
    }
}

 

第二种思路：

先把依赖关系建成树，因为可能是森林，所以再建一个根节点把每个树的根节点连起来就可以。
然后树上跑dfs，在回溯的过程中跑01背包。
dp[u][i]表示在以u为根节点的子树上，选i个物品的最大价值。
然后转移方程就是dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k])，就是他可以从未更新的部分选j-k个，然后在已更新的那个儿子节点那里选k个，v是当前更新到的子节点，这样把k从1到j-1扫一遍，就把这个子节点v对父节点u做的贡献做出来了。
然后这里说一下为什么j要从m到2更新，因为我们要用到dp[u][j-k]，而这个代表的是未更新当前结点的情况，所以如果j从小更新的话，dp[u][j-k]就是已更新这个子节点的情况了，然后就错了，所以j要从大到小更新

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
using namespace std;

const int maxn = 200+10;

vector<int> G[maxn];
int dp[maxn][maxn],a[maxn],va[maxn],n,m;

void dfs(int u){
    dp[u][1] = va[u];
    dp[u][0] = 0;
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i];
        dfs(v);
        for(int j=m; j>=2; j--)
            for(int k=0; k<j; k++)
                dp[u][j] = max(dp[u][j],dp[u][j-k]+dp[v][k]); 
            // for(int k=1; k<=j; k++)
            //     dp[u][j] = max(dp[u][j],dp[u][k]+dp[v][j-k]); // u选k个 子节点中选j-k个
    }
}

int main(){
    while(scanf("%d%d",&n,&m),(n+m)){
        memset(dp,0,sizeof(dp));
        for(int i=0;i<maxn;i++)
            G[i].clear();
        memset(a,0,sizeof(a));
        ++m; // 虚拟根节点0， 一定选
        for(int i=1; i<=n; i++){
            cin >> a[i] >> va[i];
            G[a[i]].push_back(i);
        }

        dfs(0);

        cout << dp[0][m] << endl;
    }
}