【恋上数据结构】动态规划（找零钱、最大连续子序列和、最长上升子序列、最长公共子序列、最长公共子串、0-1背包）

数据结构与算法笔记：恋上数据结构笔记目录

动态规划（Dynamic Programming），简称 DP

• 是求解最优化问题的一种常用策略

通常的使用套路（一步一步优化）:
① 暴力递归（自顶向下，出现了重叠子问题）
② 记忆化搜索（自顶向下）
③ 递推（自底向上）

直接学习动态规划的概念有点难以理解，先理解透一道例题再学习概念。

练习1：找零钱

leetcode_322_零钱兑换：https://leetcode-cn.com/problems/coin-change/

假设有25分、20分、5分、1分的硬币，现要找给客户41分的零钱，如何办到硬币个数最少？

• 此前用贪心策略得到的并非是最优解（贪心得到的解是 5 枚硬币：25、5、5、5、1）

假设 dp(n) 是 凑到 n 分需要的最少硬币个数：

• 如果第 1 次选择了 25 分的硬币，那么 dp(n) = dp(n - 25) + 1
• 如果第 1 次选择了 20 分的硬币，那么 dp(n) = dp(n - 20) + 1
• 如果第 1 次选择了 5 分的硬币，那么 dp(n) = dp(n - 5) + 1
• 如果第 1 次选择了 1 分的硬币，那么 dp(n) = dp(n - 1) + 1
• 所以 dp(n) = min { dp(n - 25), dp(n - 20), dp(n - 5), dp(n - 1) } + 1

找零钱 - 暴力递归

类似于斐波那契数列的递归版，会有大量的重复计算，时间复杂度较高。

/**
 * 暴力递归(自顶向下的调用, 出现了重叠子问题)
 */
static int coins(int n) {
	// 递归基
	if (n < 1) return Integer.MAX_VALUE;
	if (n == 1 || n == 5 || n == 20 || n == 25) return 1; // 边界情况
	
	// 求出四种取法的最小值
	int min1 = Math.min(coins(n - 1), coins(n - 5));
	int min2 = Math.min(coins(n - 20), coins(n - 25));
	return Math.min(min1, min2) + 1;
}

找零钱 - 记忆化搜索

static int coins(int n) {
	if (n < 1) return -1; // 处理非法数据
	int[] dp = new int[n + 1];
	int[] faces = { 1, 5, 20, 25 }; // 给定的面值数组
	
	for (int face : faces) {
		// 如果我要凑的钱是20元, 那么我肯定用不到25元面值
		if (face > n) break; // 用不到的面值不用初始化
		dp[face] = 1; // 初始化可能用到的面值
	}
	return coins(n, dp);
}
static int coins(int n, int[] dp) {
	// 递归基
	if (n < 1) return Integer.MAX_VALUE;
	if (dp[n] == 0) { // 记忆化搜索, dp[n] == 0 表示以前没有算过, 那便初始化一下
		int min1 = Math.min(coins(n - 5, dp), coins(n - 1, dp));
		int min2 = Math.min(coins(n - 25, dp), coins(n - 20, dp));
		dp[n] = Math.min(min1, min2) + 1;
	}
	return dp[n];
}

找零钱 - 递推

/**
 * 递推(自底向上)
 */
static int coins(int n) {
	if (n < 1) return -1; // 处理非法数据
	int[] dp = new int[n + 1];
	// 自底向上的递推
	for (int i = 1; i <= n; i++) {
		int min = Integer.MAX_VALUE;
		if (i >= 1) min = Math.min(min, dp[i - 1]);
		if (i >= 5) min = Math.min(min, dp[i - 5]);
		if (i >= 20) min = Math.min(min, dp[i - 20]);
		if (i >= 25) min = Math.min(min, dp[i - 25]);
		dp[i] = min + 1;
	}
	return dp[n];
}

可以修改一下写法：

static int coins(int n) {
	if (n < 1) return -1; // 处理非法数据
	int[] dp = new int[n + 1];
	// 递推(自底向上)过程
	for (int i = 1; i <= n; i++) {
		int min = dp[i - 1]; // 由于下面两行是必然执行的, 直接这么写就行了
		// int min = Integer.MAX_VALUE;
		// if (i >= 1) min = Math.min(min, dp[i - 1]);
		if (i >= 5) min = Math.min(min, dp[i - 5]);
		if (i >= 20) min = Math.min(min, dp[i - 20]);
		if (i >= 25) min = Math.min(min, dp[i - 25]);
		dp[i] = min + 1;
	}
	return dp[n];
}

思考题：输出找零钱的具体方案（具体是用了哪些面值的硬币）

static int coins4(int n) {
	if (n < 1) return -1; // 处理非法数据
	int[] dp = new int[n + 1];
	// faces[i]是凑够i分时最后选择的那枚硬币的面值
	int[] faces = new int[dp.length]; // 存放硬币面值(为了输出)
	for (int i = 1; i <= n; i++) {
		int min = Integer.MAX_VALUE;
		if (i >= 1 && dp[i - 1] < min) {
			min = dp[i - 1];
			faces[i] = 1;
		}
		// 上面一步其实必然执行, 可以直接写成下面这样
		// int min = dp[i - 1];
		// faces[i] = 1;
		if (i >= 5 && dp[i - 5] < min) {
			min = dp[i - 5];
			faces[i] = 5;
		}
		if (i >= 20 && dp[i - 20] < min) {
			min = dp[i - 20];
			faces[i] = 20;
		}
		if (i >= 25 && dp[i - 25] < min) {
			min = dp[i - 25];
			faces[i] = 25;
		}
		dp[i] = min + 1;
		print(faces, i); // 打印凑够面值 1 ~ n 的方案
	}
	// print(faces, n); // 打印凑够面值 n 的方案
	return dp[n];
}
// 打印凑够面值 n 的方案
static void print(int[] faces, int n) {
	System.out.print("[" + n + "] = ");
	while (n > 0) {
		System.out.print(faces[n] + " ");
		n -= faces[n];
	}
	System.out.println();
}

尝试打印了 n = 41 的情况，打印出了凑够 1~41 所有面值的情况：

[1] = 1 
[2] = 1 1 
[3] = 1 1 1 
[4] = 1 1 1 1 
[5] = 5 
[6] = 1 5 
[7] = 1 1 5 
[8] = 1 1 1 5 
[9] = 1 1 1 1 5 
[10] = 5 5 
[11] = 1 5 5 
[12] = 1 1 5 5 
[13] = 1 1 1 5 5 
[14] = 1 1 1 1 5 5 
[15] = 5 5 5 
[16] = 1 5 5 5 
[17] = 1 1 5 5 5 
[18] = 1 1 1 5 5 5 
[19] = 1 1 1 1 5 5 5 
[20] = 20 
[21] = 1 20 
[22] = 1 1 20 
[23] = 1 1 1 20 
[24] = 1 1 1 1 20 
[25] = 25 
[26] = 1 25 
[27] = 1 1 25 
[28] = 1 1 1 25 
[29] = 1 1 1 1 25 
[30] = 5 25 
[31] = 1 5 25 
[32] = 1 1 5 25 
[33] = 1 1 1 5 25 
[34] = 1 1 1 1 5 25 
[35] = 5 5 25 
[36] = 1 5 5 25 
[37] = 1 1 5 5 25 
[38] = 1 1 1 5 5 25 
[39] = 1 1 1 1 5 5 25 
[40] = 20 20 
[41] = 1 20 20 
3

找零钱 - 通用实现

public static void main(String[] args) {
	System.out.println(coins5(41, new int[]{1, 5, 20, 25})); // 3
}

static int coins(int n, int[] faces) {
	if (n < 1 || faces == null || faces.length == 0 ) return -1;
	int[] dp = new int [n + 1];
	for (int i = 1; i <= n; i++) {
		int min = Integer.MAX_VALUE;
		for (int face : faces) {
			// 假如给我的面值是20, 要凑的是15, 则跳过此轮循环
			if (face > i) continue; // 如果给我的面值比我要凑的面值还大, 跳过此轮循环
			min = Math.min(dp[i - face], min);
		}
		dp[i] = min + 1;
	}
	return dp[n];
}

改进，如果不能凑成则返回 -1：

static int coins5(int n, int[] faces) {
	if (n < 1 || faces == null || faces.length == 0 ) return -1;
	int[] dp = new int [n + 1];
	for (int i = 1; i <= n; i++) {
		int min = Integer.MAX_VALUE;
		for (int face : faces) {
			// 假如给我的面值是20, 要凑的是15, 则跳过此轮循环
			if (face > i) continue; // 如果给我的面值比我要凑的面值还大, 跳过此轮循环
			// 比如给的面值是{4}, 要凑的是6, 先给出一张4, 再看6-4=2, 是否能凑成
			// 2无法凑成, 则跳过此轮循环	 
			int v = dp[i - face];
			if (v < 0 || v >= min) continue;
			min = v;
		}
		// 说明上面的循环中每次都是continue, 要凑的面值比给定的所有面值小
		if (min == Integer.MAX_VALUE) {
			dp[i] = -1;
		} else {
			dp[i] = min + 1;
		}
	}
	return dp[n];
}

动态规划（Dynamic Programming）

动态规划的常规步骤

动态规划，简称 DP

• 是求解最优化问题的一种常用策略

通常的使用套路（一步一步优化）:
① 暴力递归（自顶向下，出现了重叠子问题）
② 记忆化搜索（自顶向下）
③ 递推（自底向上）

动态规划中的 “动态” 可以理解为是 “会变化的状态”；

• ① 定义状态（状态是原问题、子问题的解）
  比如定义 $dp(i)$ 的含义
• ② 设置初始状态（边界）
  比如设置 $dp(0)$ 的值
• ③ 确定状态转移方程
  比如确定 $dp(i)$ 和 $dp(i - 1)$ 的关系

动态规划的一些概念

维基百科的解释：

Dynamic Programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems, solving each of those subproblems just once, and storing their solutions.

① 将复杂的原问题拆解成若干个简单的子问题
② 每个子问题仅仅解决1次，并保存它们的解
③ 最后推导出原问题的解

可以用动态规划来解决的问题，通常具备2个特点：

• 最优子结构（最优化原理）：通过求解子问题的最优解，可以获得原问题的最优解
• 无后效性：
  某阶段的状态一旦确定，则此后过程的演变不再受此前各状态及决策的影响（未来与过去无关）
  在推导后面阶段的状态时，只关心前面阶段的具体状态值，不关心这个状态是怎么一步步推导出来的

有后效性与无后效性

首先了解一下什么是有后效性：

然后再去理解什么是无后效性：

练习2：最大连续子序列和

题目：给定一个长度为 n 的整数序列，求它的最大连续子序列和

• 比如 -2、1、-3、4、-1、2、1、-5、4 的最大连续子序列和是 4 + (-1) + 2 + 1 = 6；
  以 nums[0] -2 结尾的最大连续子序列是 -2，所以 $dp(0) = -2$
  以 nums[1] 1 结尾的最大连续子序列是 1，所以 $dp(1) = 1$
  以 nums[2] -3 结尾的最大连续子序列是 1、-3，所以 $dp(2) = dp(1) + (-3) = -2$
  以 nums[3] 4 结尾的最大连续子序列是 4，所以 $dp(3) = 4$
  以 nums[4] -1 结尾的最大连续子序列是 4、-1，所以 $dp(4) = dp(3) + (-1) = 3$
  以 nums[5] 2 结尾的最大连续子序列是 4、-1、2，所以 $dp(5) = dp(4) + 2 = 5$
  以 nums[6] 1 结尾的最大连续子序列是 4、-1、2、1，所以 $dp(6) = dp(5) + 1 = 6$
  以 nums[7] -5 结尾的最大连续子序列是 4、-1、2、1、-5，所以 $dp(7) = dp(6) + (-5) = 1$
  以 nums[8] 4 结尾的最大连续子序列是 4、-1、2、1、-5、4，所以 $dp(8) = dp(7) + 4 = 5$

状态转移方程和初始状态：
状态转移方程：

• 如果 $dp(i – 1) ≤ 0$，那么 $dp(i) = nums[i]$
• 如果 $dp(i – 1) > 0$，那么 $dp(i) = dp(i – 1) + nums[i]$

初始状态：

• $dp(0)$ 的值是 $nums[0]$

最终的解：

• 最大连续子序列和是所有 $dp(i)$ 中的最大值 $max \{ dp(i) \}，i ∈ [0, nums.length)$

最大连续子序列和 – 实现

static int maxSubArray(int[] nums) {
	if (nums == null || nums.length == 0) return 0;
	int[] dp = new int[nums.length];
	int max = dp[0] = nums[0];
	for (int i = 1; i < dp.length; i++) {
		if (dp[i - 1] > 0) {
			dp[i] = dp[i - 1] + nums[i];
		} else {
			dp[i] = nums[i];
		}
		max = Math.max(max, dp[i]);
	}
	return max;
}

最大连续子序列和 – 优化

static int maxSubArray(int[] nums) {
	if (nums == null || nums.length == 0) return 0;
	int dp = nums[0];
	int max = dp;
	for (int i = 1; i < nums.length; i++) {
		if (dp > 0) {
			dp = dp + nums[i];
		} else {
			dp = nums[i];
		}
		max = Math.max(max, dp);
	}
	return max;
}

练习3：最长上升子序列（LIS）

最长上升子序列（最长递增子序列，Longest Increasing Subsequence，LIS）

leetcode_300_最长上升子序列： https://leetcode-cn.com/problems/longest-increasing-subsequence/

题目：给定一个无序的整数序列，求出它最长上升子序列的长度（要求严格上升）

• 比如 [10, 2, 2, 5, 1, 7, 101, 18] 的最长上升子序列是 [2, 5, 7, 101]、[2, 5, 7, 18]，长度是 4

假设数组是 nums， [10, 2, 2, 5, 1, 7, 101, 18]

• $dp(i)$ 是以 $nums[i]$ 结尾的最长上升子序列的长度， $i ∈ [0, nums.length)$
  以 nums[0] 10 结尾的最长上升子序列是 10，所以 $dp(0) = 1$
  以 nums[1] 2 结尾的最长上升子序列是 2，所以 $dp(1) = 1$
  以 nums[2] 2 结尾的最长上升子序列是 2，所以 $dp(2) = 1$
  以 nums[3] 5 结尾的最长上升子序列是 2、5，所以 $dp(3) = dp(1) + 1 = dp(2) + 1 = 2$
  以 nums[4] 1 结尾的最长上升子序列是 1，所以 $dp(4) = 1$
  以 nums[5] 7 结尾的最长上升子序列是 2、5、7，所以 $dp(5) = dp(3) + 1 = 3$
  以 nums[6] 101 结尾的最长上升子序列是 2、5、7、101，所以 $dp(6) = dp(5) + 1 = 4$
  以 nums[7] 18 结尾的最长上升子序列是 2、5、7、18，所以 $dp(7) = dp(5) + 1 = 4$

状态方程：

状态的初始值：

• $dp(0) = 1$
• 所有的 $dp(i)$ 默认都初始化为 1

最终的解：

• 最长上升子序列的长度是所有 $dp(i)$ 中的最大值 $max \{ dp(i) \}，i ∈ [0, nums.length)$

最长上升子序列 – 实现

时间复杂度：O(n²)，空间复杂度：O(n)

static int lengthOfLIS(int[] nums) {
  	if (nums == null || nums.length == 0) return 0;
  	int[] dp = new int[nums.length];
  	int max = dp[0] = 1; // 只有一个元素则长度为1
  	for (int i = 1; i < dp.length; i++) {
  		dp[i] = 1; // 默认只有一个元素时长度为1
  		for (int j = 0; j < i; j++) {
  			// 无法成为一个上升子序列
  			if (nums[j] >= nums[i]) continue;
  			dp[i] = Math.max(dp[j] + 1, dp[i]);
  		}
  		max = Math.max(dp[i], max);
  	}
  	return max;
  }

最长上升子序列 – 二分搜索实现

普通实现（非二分搜索）：

static int lengthOfLIS(int[] nums) {
	if (nums == null || nums.length == 0) return 0;
	// 牌堆的数量
	int len = 0;
	// 牌顶数组
	int[] top = new int[nums.length];
	// 遍历所有的牌
	for (int num : nums) {
		int j = 0;
		while (j < len) {
			// 找到一个>=nums的牌顶
			if (top[j] >= num) {
				top[j] = num;
				break;
			}
			// 牌顶 < nums
			j++;
		}
		if (j == len) { // 新建一个牌堆
			len++;
			top[j] = num;
		}
	}
	return len;
}

二分搜索实现：

static int lengthOfLIS(int[] nums) {
	if (nums == null || nums.length == 0) return 0;
	// 牌堆的数量
	int len = 0;
	// 牌顶数组
	int[] top = new int[nums.length];
	// 遍历所有的牌（二分搜索）
	for (int num : nums) {
		int begin = 0;
		int end = len;
		while (begin < end) {
			int mid = (begin + end) >> 1;
			if (num <= top[mid]) {
				end = mid;
			} else {
				begin = mid + 1;
			}
		}
		// 覆盖牌顶
		top[begin] = num;
		// 检查是否要新建一个牌堆
		if (begin == len) len++;
	}
	return len;
}

练习4 – 最长公共子序列（LCS）

最长公共子序列（Longest Common Subsequence，LCS）

leetcode_1143_最长公共子序列：https://leetcode-cn.com/problems/longest-common-subsequence/

题目：求两个序列的最长公共子序列长度

• [1, 3, 5, 9, 10] 和 [1, 4, 9, 10] 的最长公共子序列是 [1, 9, 10]，长度为 3
• ABCBDAB 和 BDCABA 的最长公共子序列长度是 4，可能是
  ABCBDAB 和 BDCABA > BDAB
  ABCBDAB 和 BDCABA > BDAB
  ABCBDAB 和 BDCABA > BCAB
  ABCBDAB 和 BDCABA > BCBA

思路：

最长公共子序列 – 递归实现

• 空间复杂度：O(k) , k = min{n, m}，n、m 是 2 个序列的长度
• 时间复杂度：O(2ⁿ) ，当 n = m 时

/**
 * 递归实现
 */
static int lcs(int[] nums1, int[] nums2) {
	if (nums1 == null || nums1.length == 0) return 0; // 检测非法数据
	if (nums2 == null || nums2.length == 0) return 0; // 检测非法数据
	return lcs(nums1, nums1.length, nums2, nums2.length);
}
/**
 * 求nums1前i个元素和nums2前j个元素的最长g公共子序列长度
 * @param nums1
 * @param i
 * @param nums2
 * @param j
 */
static int lcs(int[] nums1, int i, int[] nums2, int j) {
	if (i == 0 || j == 0) return 0;
	// 最后一个元素相等, 返回前面的公共子序列长度 + 1
	if (nums1[i - 1] == nums2[j - 1]) {
		return lcs(nums1, i - 1, nums2, j - 1) + 1;
	}
	return Math.max(
		lcs(nums1, i - 1, nums2, j), 
		lcs(nums1, i, nums2, j - 1)
	);
}

最长公共子序列 – 非递归实现

• 空间复杂度：O(n ∗ m)
• 时间复杂度：O(n ∗ m)

static int lcs(int[] nums1, int[] nums2) {
	if (nums1 == null || nums1.length == 0) return 0;
	if (nums2 == null || nums2.length == 0) return 0;
	int[][] dp = new int[nums1.length + 1][nums2.length + 1];
	
	for (int i = 1; i <= nums1.length; i++) {
		for (int j = 1; j <= nums2.length; j++) {
			if (nums1[i - 1] == nums2[j - 1]) {
				dp[i][j] = dp[i - 1][j - 1] + 1;
			} else {
				dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
			}
		}
	}
	return dp[nums1.length][nums2.length];
}

最长公共子序列 – 滚动数组优化

可以使用滚动数组优化空间复杂度。

/**
 * 非递归实现(滚动数组优化)
 */
static int lcs(int[] nums1, int[] nums2) {
	if (nums1 == null || nums1.length == 0) return 0;
	if (nums2 == null || nums2.length == 0) return 0;
	int[][] dp = new int[2][nums2.length + 1];
	
	for (int i = 1; i <= nums1.length; i++) {
		int row = i & 1;
		int prevRow = (i - 1) & 1;
		for (int j = 1; j <= nums2.length; j++) {
			if (nums1[i - 1] == nums2[j - 1]) {
				dp[row][j] = dp[prevRow][j - 1] + 1;
			} else {
				dp[row][j] = Math.max(dp[prevRow][j], dp[row][j - 1]);
			}
		}
	}
	return dp[nums1.length & 1][nums2.length];
}

最长公共子序列 – 一维数组优化

练习5 – 最长公共子串

最长公共子串（Longest Common Substring）

• 子串是连续的子序列

题目：求两个字符串的最长公共子串长度

• ABCBA 和 BABCA 的最长公共子串是 ABC，长度为 3

假设 2 个字符串分别是 str1、str2：

• i ∈ [1, str1.length]
• j ∈ [1, str2.length]

假设 $dp(i, j)$ 是以 str1[i – 1]、str2[j – 1] 结尾的最长公共子串长度：

• $dp(i, 0)$、 $dp(0, j)$ 初始值均为 0
• 如果 str1[i – 1] = str2[j – 1]，那么 $dp(i, j) = dp(i – 1, j – 1) + 1$
• 如果 str1[i – 1] ≠ str2[j – 1]，那么 $dp(i, j) = 0$

最长公共子串 – 实现

• 空间复杂度：O(n ∗ m)
• 时间复杂度：O(n ∗ m)

	static int lcs(String str1, String str2) {
		if (str1 == null || str2 == null) return 0;
		char[] chars1 = str1.toCharArray();
		if (chars1.length == 0) return 0;
		char[] chars2 = str2.toCharArray();
		if (chars2.length == 0) return 0;
		
		int [][] dp = new int [chars1.length + 1][chars2.length + 1];
		int max = 0;
		for (int i = 1; i <= chars1.length; i++) {
			for (int j = 1; j <= chars2.length; j++) {
				if (chars1[i - 1] != chars2[j - 1]) continue;
					dp[i][j] = dp[i -1][j - 1] + 1;
					max = Math.max(max, dp[i][j]);
			}
		}
		return max;
	}

最长公共子串 – 一维数组优化

• 空间复杂度：O(k) , k = min{n, m}
• 时间复杂度：O(n ∗ m)

static int lcs(String str1, String str2) {
	if (str1 == null || str2 == null) return 0;
	char[] chars1 = str1.toCharArray();
	if (chars1.length == 0) return 0;
	char[] chars2 = str2.toCharArray();
	if (chars2.length == 0) return 0;
	// 选取长度较短的作为列
	char[] rowsChars = chars1, colsChars = chars2;
	if (chars1.length < chars2.length) {
		colsChars = chars1;
		rowsChars = chars2;
	}
	
	int[] dp = new int[colsChars.length + 1];
	int max = 0;
	for (int row = 1; row <= rowsChars.length; row++) {
		int cur = 0;
		for (int col = 1; col <= colsChars.length; col++) {
			int leftTop = cur;
			cur = dp[col];
			if (chars1[row - 1] != chars2[col - 1]) {
				dp[col] = 0;
			} else {
				dp[col] = leftTop + 1;
				max = Math.max(max, dp[col]);
			}
		}
	}
	return max;
}

我觉得可以修改成这样：

static int lcs(String str1, String str2) {
if (str1 == null || str2 == null) return 0;
	char[] chars1 = str1.toCharArray();
	if (chars1.length == 0) return 0;
	char[] chars2 = str2.toCharArray();
	if (chars2.length == 0) return 0;
	// 选取长度较短的作为列
	int rowsLength = chars1.length;
	int colsLength = chars2.length;
	if (chars1.length < chars2.length) {
		colsLength = chars1.length;
		rowsLength = chars2.length;
	}
	
	int[] dp = new int[colsLength + 1];
	int max = 0;
	for (int row = 1; row <= rowsLength; row++) {
		int cur = 0;
		for (int col = 1; col <= colsLength; col++) {
			int leftTop = cur;
			cur = dp[col];
			if (chars1[row - 1] != chars2[col - 1]) {
				dp[col] = 0;
			} else {
				dp[col] = leftTop + 1;
				max = Math.max(max, dp[col]);
			}
		}
	}
	return max;
}

练习6 – 0-1背包

0-1背包 – 实现

static int maxValue(int[] values, int[] weights, int capacity) {
	// 检测非法输入
	if (values == null || values.length == 0) return 0;
	if (weights == null || weights.length == 0) return 0;
	if (weights.length != values.length) return 0;
	if (capacity <= 0) return 0;
	
	// 特征方程: dp(i, j) 是最大承重为 j、有前 i 件物品可选时的最大总价值;
	int[][] dp = new int[values.length + 1][capacity + 1];
	// dp 初始化的值默认是0,Java中数组默认初始值即为0
	for (int i = 1; i <= values.length; i++) {
		for (int j = 1; j <= capacity; j++){
			if (weights[i - 1] > j) { // 如果本次挑选的物品重量 > 承重, 则不装入该物品
				dp[i][j] = dp[i - 1][j];
			} else { // 本次挑选的物品重量 <= 承重, 可以选择装入
				// 比较【装】与【不装】分别获得的最大总价值来选择
				dp[i][j] = Math.max(dp[i - 1][j], 
						dp[i - 1][j - weights[i - 1]] + values[i - 1]);
			}
		}
	}
	return dp[values.length][capacity];
}

public static void main(String[] args) {
	int[] values = { 6, 3, 5, 4, 6 };
	int[] weights = { 2, 2, 6, 5, 4 };
	int capacity = 10;
	System.out.println(maxValue1(values, weights, capacity));
	// i = 5
	// j = 10
	// 如果不选择第i个物品, dp(i, j) = dp(i - 1, j)
	// 如果选择第i个物品, dp(i, j) = values[i] + dp(i - 1, j - weights[i])
	// dp(i, j) = max {dp(i - 1, j), valus[i] + dp(i - 1, j - weights[i])}
}

0-1背包 – 一维数组

/**
 * 一维数组
 */
static int maxValue(int[] values, int[] weights, int capacity) {
	if (values == null || values.length == 0) return 0;
	if (weights == null || weights.length == 0) return 0;
	if (weights.length != values.length) return 0;
	if (capacity <= 0) return 0;
	int[] dp = new int[capacity + 1];
	
	for (int i = 1; i <= values.length; i++) {
		for (int j = capacity; j >= 1; j--) {
			if (j < weights[i - 1]) continue;
			dp[j] = Math.max(dp[j], 
					dp[j - weights[i - 1]] + values[i - 1]);
		}
	}
	return dp[capacity];
}

0-1背包 – 一维数组优化

/**
 * 一维数组优化
 */
static int maxValue(int[] values, int[] weights, int capacity) {
	// 检测非法数据
	if (values == null || values.length == 0) return 0;
	if (weights == null || weights.length == 0) return 0;
	if (weights.length != values.length) return 0;
	if (capacity <= 0) return 0;
	
	int[] dp = new int[capacity + 1];
	for (int i = 1; i <= values.length; i++) {
		for (int j = capacity; j >= weights[i - 1]; j--) {
			dp[j] = Math.max(dp[j], 
					dp[j - weights[i - 1]] + values[i - 1]);
		}
	}
	return dp[capacity];
}

0-1背包 – 恰好装满 – 实现

/**
 * 恰好装满
 */
static int maxValue4(int[] values, int[] weights, int capacity) {
	// 检测非法数据
	if (values == null || values.length == 0) return 0;
	if (weights == null || weights.length == 0) return 0;
	if (weights.length != values.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 <= values.length; i++) {
		for (int j = capacity; j >= weights[i - 1]; j--) {
			dp[j] = Math.max(dp[j], 
					dp[j - weights[i - 1]] + values[i - 1]);
		}
	}
	return dp[capacity] < 0 ? -1 : dp[capacity];
}