01背包理论和有依赖的背包

01背包

有n件物品和⼀个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

这是标准的背包问题

举⼀个例⼦：

背包最大重量为4。

物品为：

问背包能背的物品最大价值是多少？

以下讲解和图示中出现的数字都是以这个例子为例。

⼆维dp数组01背包

1. 确定dp数组以及下标的含义

对于背包问题，有⼀种写法， 是使用⼆维数组，即dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

2. 确定递推公式

再回顾⼀下 dp[i][j] 的含义：从下标为[0-i]的物品⾥任意取，放进容量为j的背包，价值总和最大是多少。

那么可以有两个方向推出来dp[i][j]，

不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其 实就是当物品i的重量⼤于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)

放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品 i 得到的最大价值

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

3. dp数组如何初始化

关于初始化，⼀定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。 首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和⼀定为0。如图：

在看其他情况。

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

可以看出i 是由 i-1 推导出来，那么i为0的 时候就⼀定要初始化。

dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还⼩。

当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

代码初始化如下

此时dp数组初始化情况如图所示：

dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？

其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上⽅数值推 导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖。

初始-1，初始-2，初始100，都可以！ 但只不过⼀开始就统⼀把dp数组统⼀初始为0，更方便⼀些。

如图：

4. 确定遍历顺序

在如下图中，可以看出，有两个遍历的维度：物品与背包重量

那么问题来了，先遍历 物品还是先遍历背包重量呢？

其实都可以！！ 但是先遍历物品更好理解。

以下代码为先遍历物品再遍历背包

为什么都可以的呢？

要理解递归的本质和递推的方向。

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。

dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品，再遍历背包的过程如图所示：

再来看看先遍历背包，再遍历物品呢，如图：

大家可以看出，虽然两个for循环遍历的次序不同，但是 dp[i][j] 所需要的数据就是左上角，根本不影响 dp[i][j] 公式 的推导！

但先遍历物品再遍历背包这个顺序更好理解。

其实背包问题⾥，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了

5.打印dp数组

最后的ac代码

⼀维dp数组（滚动数组）

背包最⼤重量为4。

物品为：

问背包能背的物品最大价值是多少？

对于背包问题其实状态都是可以压缩的。

在使用⼆维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

其实可以发现如果把dp[i - 1]那⼀层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

与其把dp[i - 1]这⼀层拷贝到dp[i]上，不如只用⼀个⼀维数组了，只⽤dp[j]（⼀维数组，也可以理解是⼀个滚动数组。

这就是滚动数组的由来，需要满足的条件是上⼀层，它可以重复利用，直接拷贝到当前层。

1. 确定dp数组的定义

在⼀维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]

2. ⼀维dp数组的递推公式

dp[j]为 容量为j的背包所背的最大价值，那么如何推导dp[j]呢？

dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最⼤价值。

dp[j - weight[i]] + value[i] 表示 容量为 j - 物品 i 重量 的背包加上物品 i 的价值。（也就是容量为 j 的背包，放入物品 i 了之后的价值即：dp[j]）

此时dp[j]有两个选择，⼀个是取自己dp[j]相当于⼆维dp数组中的dp[i-1][j]，即不放物品i，⼀个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值， 所以递归公式为：

3. ⼀维dp数组如何初始化

关于初始化，⼀定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

dp[j]表示：容量为 j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品 的最大价值就是0。

那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？

看⼀下递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

dp数组在推导的时候⼀定是取价值最大的数，如果题目给的价值都是正整数那么非0下标，那都初始化为0就可以了。

这样才能让dp数组在递归公式的过程中取的最大的价值，而不会被初始值覆盖了。

那么我假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0就可以了。

4. ⼀维dp数组遍历顺序

代码如下：

这里大家发现和⼆维dp的写法中，遍历背包的顺序是不⼀样的！

⼆维dp遍历的时候，背包容量是从小到大，而⼀维dp遍历的时候，背包是从大到小。

为什么呢？

倒序遍历是为了保证物品i只被放入一次！

但如果⼀旦正序遍历了，那么物品0就会被重复加入多次！

举⼀个例子：物品0的重量weight[0] = 1，价值value[0] = 15

如果正序遍历

dp[1] = dp[1 - weight[0]] + value[0] = 15

dp[2] = dp[2 - weight[0]] + value[0] = 30

此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。

为什么倒序遍历，就可以保证物品只放入一次呢？

倒序就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）

dp[1] = dp[1 - weight[0]] + value[0] = 15

因为动态规划是从前面的状态来推导出后面的状态，如果先推导后面的状态，这样就不会和之前取得状态重合，这样每种物品就只取⼀次了。

那么问题又来了，为什么⼆维dp数组历的时候不用倒序呢？

因为对于⼆维dp，dp[i][j]都是通过上⼀层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖！

再来看看两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？

不可以！

因为⼀维dp的写法，背包容量⼀定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上⼀层，那么每个 dp[j]就只会放入⼀个物品，即：背包里只放入了⼀个物品。

倒序遍历的原因是，本质上还是⼀个对⼆维数组的遍历，并且右下角的值依赖上⼀层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。

所以⼀维dp数组的背包在遍历顺序上和⼆维其实是有很大差异的！

5. 打印dp数组

最后的ac代码

有依赖背包

概念

多个物品变成一个复合物品（互斥），每件复合物品不要和怎么要多种可能性展开

不能用01背包来解，但是非常重要的问题

有依赖的背包问题一般会有一定的限制条件，例如选择某一件的前提是选择了另一件物品， 选第 i 件物品，就必须选择第 j 件物品，保证不会循环引用。

一般我们称呼不依赖于别的物品的物品为主件，依赖于某主件的物品称为附件

对于包含一个主件 和若干个附件 的结合由以下可能性：

    1、不要该主件

    2、仅选择主件

    3、选择主件再选择一个附件

    4、选择主件再选择两个附件

            ............

    n、选择主件再选择全部的附件

我们假设以下情况：

因此我们可以做出下表：

因此我们可以考虑一下的状态

    1、不要该主件

    2、仅选择主件

    3、选择主件再选择一个附件

    4、选择主件再选择两个附件

            ............

    n、选择主件再选择全部的附件

我们要定义三个数组

bool king[ ] ：表示 i 号商品是否是主件商品 （用于当遍历到 i 物品时，考虑是否要对其考虑附件）

int fans[ ] ：表示 i 号商品有几个附件

int follow[ i ][ j ] ：用于记录 i 号商品的附件的序号（如果没有附件，就是为空数组）

代码：

# include <stdio.h>
# include <string.h>
int n; //总金额 
int m; //商品数量 
int follow[100][2];
int king[100];
int fan[100];
int cost[100];
int val[100];
int dp[100];

int com()
{
	int dp[m+1][n+1]; //dp[i][j] 表示0~i中只关心主商品，并且进行展开
					//花费不超过 j 的最大价值 
	int p = 0; //上次展开的主商品编号 
	for (int i=1; i<=m; ++i)
	{
		if (king[i])
		{
			for (int j=0; j<n; ++j)
			{
				dp[i][j] = dp[p][j]; // 可能性1：不考虑主商品
				if ( j >= cost[i]) // 可能性2：只考虑主商品
					dp[i][j] = max(dp[i][j], dp[i][j-cost[i]] + val[i]);	
				int fan1; //如果有一个附件，编号给fan1，不然-1 
				int fan2; //如果有两个附件，编号给fan2，不然-1
				if (fan[i] >= 1)
					fan1 = fan[i][0];
				else
					fan1 = -1;
				if (fan[i] >= 2)
					fan2 = fan[i][1];
				else
					fan2 = -1;
				if (fan1 != -1 && j-cost[i]-cost[fan1] >= 0) //可能性3：要主件和一个附件1
					dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan1]] + val[fan1] + val[i]);
				if (fan2 != -1 && j-cost[i]-cost[fan2] >= 0)//可能性4：要主件和一个附件2 
					dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan2]] + val[fan2] + val[i]);
				if (fan2 != -1 && fan1 != -1  && j-cost[i]-cost[fan2]-cost[fan1] >= 0)//可能性5：要主件和两个附件 
					dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan2]-cost[fan1]] + val[fan2] + val[i] + val[fan1]);
								
			}
			p = i;
		}
	} 
}

int main()
{
	scanf("%d %d", &n, &m);
	memset(fan, 0, sizeof(fan));
	memset(king, 0, sizeof(king));
	int v; //花费 
	int p; //重要度 
	int q; //归属 
	for (int i=1; i<=m; ++i)
	{
		scanf("%d %d %d", &v, &p, &q);
		cost[i] = v;
		val[i] = v * p;
		if (q == 0)
			king[i] = 0;
		else
			king[i] = 1;
		if (q != 0)
		{
			follow[q][fan[q]] = i;
			fan[q]++;
		}
	}
	int ans;
	ans = com();
}