数据结构与算法---动态规划---0-1背包问题

0-1背包问题，我们在数据结构与算法—贪心中谈论过。当时是使用重量优先、价值优先、性价比优先三种贪心策略，使用贪心策略解决的问题。但，这种解决问题的答案并不是最优解。
现在我们使用DP来解决0-1背包问题。

思路

是否为最值问题？

求背包最多装载量，是最值问题

能否使用DP？

1. 原问题能否分解为子问题？
   可以

2. 无后效性
   满足

使用DP步骤？

假设values是价值数组，weights是重量数组
编号为k的物品，价值是values[k]，重量是weights[k]，k∈[0, n)

1. 确定含义
   假设dp(i, j)为：最大承重量为j，有前i件物品可选 时的最大总价值，i∈[0, n]，j∈[0, W]

有前i件物品可选，是指相当于就三个物品，你可以选择其中的任意，也可以都不选。

2. 确定边界值
   dp(0, j) = 0;
   dp(i, 0) = 0;

3. 状态转移方程

第i件，就是weights[i - 1]

如果 j < weights[i - 1]，说明最大承重量 小于 要选择的物品重量，说明，肯定不选
dp(i, j) = dp(i - 1, j);

比如weights = {2, 2, 6, 2, 6};
dp(5, 5)代表前5个元素可选，最大承重量为5
最后一个物品的重量是6，6>5，最后一个物品是不会被选中的。

如果 j >= weights[i - 1]，说明最大承重量 大于或等于 要选择的物品重量，说明，有空间，可以选，当然，也可以不选。
这就存在两种情况：
如果weights[i - 1]不选，则dp(i, j) = dp(i - 1, j);
如果weights[i - 1]选，则dp(i, j) = values[i - 1] + dp(i - 1, j - weights[i - 1]);
可以合并为：dp(i, j) = max{dp(i - 1, j), values[i - 1] + dp(i - 1, j - weights[i - 1])};

package dynamicProgramming;

public class Knapsack {
	public static void main(String[] agrs)
	{
		int[] values = {6, 3, 5, 4, 6};
		int[] weights = {2, 2, 6, 5, 4};
		int capacity = 10;
		System.out.println(maxValue(values, weights, capacity));
	}
	
	static int maxValue(int[] values, int[] weights, int capacity)
	{
		if (values == null || weights == null) return 0;
		if (values.length == 0 || weights.length == 0) return 0;
		if (values.length != weights.length) return 0;
		if (capacity == 0) return 0;
		
		//weights.length或者values.length都可以，前面已经判断，两个数组长度相等
		//dp[i][j] 最大承重量为j，有前i件物品可选时的最大总价值
		int[][] dp = new int[weights.length + 1][capacity + 1];
		//dp[0][j] = dp[i][0] = 0，但是不需要写。因为，二维数组初始化的时候就为0
		for (int i = 1; i <= weights.length; i++) {
			for (int j = 1; j <= capacity; j++) {
				if (j < weights[i - 1]) {
					dp[i][j] = dp[i - 1][j];
				}else {
					dp[i][j] = Math.max(dp[i - 1][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]);
				}
			}
		}
		
		return dp[weights.length][capacity];
	}
}

复杂度分析

时间复杂度：O(n* m)，物品个数 * 最大承重量
空间复杂度：O(n* m)，物品个数 * 最大承重量

dp计算出来的结果制成图，如下：

---

优化-一维数组

从结果图中可以观察出，dp(i, j)的值结果，只需要借助dp(i - 1,* ) 的结果即可。
也就是，我们只需要一个一维数组存储dp(i - 1, * )的数据即可。
需要注意的是，j需要从大到小，倒叙计算。

package dynamicProgramming;

public class Knapsack {
	public static void main(String[] agrs)
	{
		int[] values = {6, 3, 5, 4, 6};
		int[] weights = {2, 2, 6, 5, 4};
		int capacity = 10;
		System.out.println(maxValue1(values, weights, capacity));
	}
	
	static int maxValue1(int[] values, int[] weights, int capacity)
	{
		if (values == null || weights == null) return 0;
		if (values.length == 0 || weights.length == 0) return 0;
		if (values.length != weights.length) return 0;
		if (capacity == 0) return 0;
		
		int[] dp = new int[capacity + 1];
		for (int i = 1; i <= weights.length; i++) {
			for (int j = capacity; j >= 1; j--) {
				if (j < weights[i - 1]) {//如果要选择的物品大于容量
					dp[j] = dp[j];//直接把该值保留
					//或者写成continue;
				}else {
					dp[j] = Math.max(dp[j], values[i - 1] + dp[j - weights[i - 1]]);
				}
			}
		}
		
		return dp[capacity];
	}
}

复杂度分析

时间复杂度：O(n* m)，物品个数 * 最大承重量
空间复杂度：O(capacity)，最大承重量

---

• 再次优化

更优化方案，思路一样，只是减少循环次数，参考

package dynamicProgramming;

public class Knapsack {
	public static void main(String[] agrs)
	{
		int[] values = {6, 3, 5, 4, 6};
		int[] weights = {2, 2, 6, 5, 4};
		int capacity = 10;
		System.out.println(maxValue1(values, weights, capacity));
	}
	
	static int maxValue1(int[] values, int[] weights, int capacity)
	{
		if (values == null || weights == null) return 0;
		if (values.length == 0 || weights.length == 0) return 0;
		if (values.length != weights.length) return 0;
		if (capacity == 0) return 0;
		
		int[] dp = new int[capacity + 1];
		for (int i = 1; i <= weights.length; i++) {
			for (int j = capacity; j >= weights[i - 1]; j--) {
				dp[j] = Math.max(dp[j], values[i - 1] + dp[j - weights[i - 1]]);
			}
		}
		
		return dp[capacity];
	}
}

---

0-1背包问题：恰好装满

题意修改：总重量恰好等于背包最大承重量W，求背包的最大总价值为多少？

思路与上面差不多，不同点在于dp(i, j)的初始化上
dp(i, 0) = 0，背包最大承重量为0，那么最大价值也为0，这个不变。
dp(0, j) = 负无穷，物品个数为0，怎么也不会有最大价值，其实是0，但由于是一维数组，优化过后，后面的值要使用到前面的值，因此，定义为负无穷。以防止后面由于加法运算，产生错误。

难度还是比较大的

package dynamicProgramming;

public class Knapsack {
	public static void main(String[] agrs)
	{
		int[] values = {6, 3, 5, 4, 6};
		int[] weights = {2, 2, 6, 5, 4};
		int capacity = 10;
		System.out.println(maxValueExactly(values, weights, capacity));
	}
	
	/**恰好装满背包的情况*/
	static int maxValueExactly(int[] values, int[] weights, int capacity)
	{
		if (values == null || weights == null) return 0;
		if (values.length == 0 || weights.length == 0) return 0;
		if (values.length != weights.length) return 0;
		if (capacity == 0) return 0;
		
		int[] dp = new int[capacity + 1];
		//初始化为负无穷
		for (int j = 1; j <= capacity; j++) {
			dp[j] = Integer.MIN_VALUE;
		}
		
		for (int i = 1; i <= weights.length; i++) {
			for (int j = capacity; j >= 1; j--) {
				if (j < weights[i - 1]) {//如果要选择的物品大于容量
					dp[j] = dp[j];//直接把该值保留
				}else {
					dp[j] = Math.max(dp[j], values[i - 1] + dp[j - weights[i - 1]]);
				}
			}
		}
		
		//返回-1代表无法恰好装满背包
		return dp[capacity] < 0 ? -1 : dp[capacity];
	}
}