• 題目描述
  • • 輸入格式
    • 輸出格式
    • 資料範圍
    • 輸入樣例
    • 輸出樣例：
• dfs+分組揹包
  • 分析
  • 程式碼
  • 時間複雜度
• 參考文章

題目傳送門

題目描述

有 NN 個物品和一個容量是 VV 的揹包。

物品之間具有依賴關係，且依賴關係組成一棵樹的形狀。如果選擇一個物品，則必須選擇它的父節點。

如下圖所示：

如果選擇物品5，則必須選擇物品1和2。這是因為2是5的父節點，1是2的父節點。

每件物品的編號是 ii，體積是 vivi，價值是 wiwi，依賴的父節點編號是 pipi。物品的下標範圍是 1…N1…N。

求解將哪些物品裝入揹包，可使物品總體積不超過揹包容量，且總價值最大。

輸出最大價值。

輸入格式

第一行有兩個整數 N，VN，V，用空格隔開，分別表示物品個數和揹包容量。

接下來有 NN 行資料，每行資料表示一個物品。
第 ii 行有三個整數 vi,wi,pivi,wi,pi，用空格隔開，分別表示物品的體積、價值和依賴的物品編號。
如果 pi=−1pi=−1，表示根節點。 資料保證所有物品構成一棵樹。

輸出格式

輸出一個整數，表示最大價值。

資料範圍

1≤N,V≤1001≤N,V≤100
1≤vi,wi≤1001≤vi,wi≤100

父節點編號範圍：

• 內部結點：1≤pi≤N1≤pi≤N;
• 根節點 pi=−1pi=−1;

輸入樣例

5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2
 

輸出樣例：

11

dfs+分組揹包

分析

樹上分組揹包問題

對一個節點u，用f[u][j]表示當容量為j的時候，以u為根的子樹的最大價值

那麼需要求的就是f[root][m]

對每個節點u的話，如何求其f[u][0 ~ m]：

• 首先將u的每個孩子看成一個分組，分組內部按體積劃分
• 根據分組揹包的思想，需要三重迴圈
  • 第一重i迴圈遍歷所有分組（即u的所有孩子）
    • 第二重迴圈j遍歷所有體積（注意u節點必選，所以體積為m -> m - v[u]，同時注意倒序列舉體積，原理同01揹包一維優化類似）
      • 第三重迴圈k就是組內列舉，這裡組內按照分給該孩子的體積劃分，所以體積為0 -> j

程式碼

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;

int root;
int n, m; // 

int f[N][N]; // f[u][j] 表示當前節點為u，體積為j能夠有的最大價值
int v[N], w[N]; // v是體積，w是價值 

int h[N], e[N], ne[N], idx = 0;
void add(int a, int b)
{
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx++;
}

void dfs(int u)
{
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int son = e[i]; // u的孩子節點son被選中 
		dfs(son); // 遞迴找到son的所有f[i][j] 
		
		for(int j = m - v[u]; j >= 0; j--) // 當前節點u一定要選，那麼剩餘體積就是m-v[u] 
		{
			//son組內按照體積大小劃分！ k是分給son的體積 
			for(int k = 0; k <= j; k++)
			{
				f[u][j] = max(f[u][j], f[son][k] + f[u][j - k]); // son分得了k大小的體積，u還剩j-k 
							 // 注意等式右邊的f[u][j], f[u][j-k]都是上一輪求出來的 
			}
		} 
	}
	
	// 這裡也是錯的！//for(int j = v[u]; j <= m; j++) f[u][j] = f[u][j-v[u]] + w[u]; 
	
	// 體積一定是從大到小迴圈，不能從小到大，因為這裡是用曉得更新大的
	// 和01揹包優化的時候類似！ 
	for(int j = m; j >= v[u]; j--) f[u][j] = f[u][j-v[u]] + w[u]; // 大於等於v[u]的情況都加上u的價值
	
	for(int j = 0; j < v[u]; j++)  f[u][j] = 0; // 小於等於v[u]的時候，u節點都不能選，其他孩子更不能選，所以價值是0
	 
}

int main()
{
	memset(h, -1, sizeof h);
	
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
	{
		int p;
		scanf("%d%d%d", &v[i], &w[i], &p);
		if(p == -1) root = i;
		else		add(p, i); // p->i
	}
	dfs(root);
	
	printf("%d\n", f[root][m]);
	return 0; 
}

解法2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;

int root;
int n, m; // 

int f[N][N]; // f[u][j] 表示當前節點為u，體積為j能夠有的最大價值
int v[N], w[N]; // v是體積，w是價值 

int h[N], e[N], ne[N], idx = 0;
void add(int a, int b)
{
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx++;
}

void dfs(int u)
{
	// u節點必選，所以
	for(int i = v[u]; i <= m; i++) f[u][i] = w[u];
	
	// 
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int son = e[i]; // u的孩子節點son被選中 
		dfs(son); // 遞迴找到son的所有f[i][j] 
		
		// 體積從大到小 
		for(int j = m; j >= v[u]; j--) 
		{
			//  son組內按照體積大小劃分！ k是分給son的體積 
			// 分給son的體積最大不能超過 j - v[u]，否則不能選擇u節點 
			for(int k = 0; k <= j - v[u]; k++)
			{
				f[u][j] = max(f[u][j], f[son][k] + f[u][j - k]); // son分得了k大小的體積，u還剩j-k 
							 // 注意等式右邊的f[u][j], f[u][j-k]都是上一輪求出來的 
			}
		} 
	}
		 
}

int main()
{
	memset(h, -1, sizeof h);
	
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
	{
		int p;
		scanf("%d%d%d", &v[i], &w[i], &p);
		if(p == -1) root = i;
		else		add(p, i); // p->i
	}
	dfs(root);
	
	printf("%d\n", f[root][m]);
	return 0; 
}

時間複雜度

參考文章

#include<iostream>
#include<vector>
using namespace std;
int f[110][110];//f[x][v]表達選擇以x為子樹的物品，在容量不超過v時所獲得的最大價值
vector<int> g[110];
int v[110],w[110];
int n,m,root;

int dfs(int x)
{
    for(int i=v[x];i<=m;i++) f[x][i]=w[x];//點x必須選，所以初始化f[x][v[x] ~ m]= w[x]
    for(int i=0;i<g[x].size();i++)
    {
        int y=g[x][i];
        dfs(y);
        for(int j=m;j>=v[x];j--)//j的範圍為v[x]~m, 小於v[x]無法選擇以x為子樹的物品
        {
            for(int k=0;k<=j-v[x];k++)//分給子樹y的空間不能大於j-v[x],不然都無法選根物品x
            {
                f[x][j]=max(f[x][j],f[x][j-k]+f[y][k]);
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int fa;
        cin>>v[i]>>w[i]>>fa;
        if(fa==-1)
            root=i;
        else
            g[fa].push_back(i);
    }
    dfs(root);
    cout<<f[root][m];
    return 0;
}

作者：yzy0611
連結：https://www.acwing.com/solution/content/8316/
來源：AcWing
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

思路略區別於dxc的思路
dfs在遍歷到 x 結點時，先考慮一定選上根節點 x ，因此初始化 f[x][v[x] ~ m] = w[x]

在分組揹包部分：

• j 的範圍 [ m , v[x] ] 小於v[x]則沒有意義因為連根結點都放不下；
• k 的範圍 [ 0 , j-v[x] ]，當大於j-v[x]時分給該子樹的容量過多，剩餘的容量連根節點的物品都放不下了；
• 詳細思路見程式碼

https://www.acwing.com/solution/content/8316/