背包问题

回溯法

回溯法类似于穷举法，可以被认为是一种有剪枝（约束函数，如01背包问题中的背包容量）的DFN（深度优先搜索）。

运用回溯法解题的关键要素有以下三点：

1. 针对给定的问题，定义问题的解空间；
2. 确定易于搜索的解空间结构；
3. 以深度优先方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

问题举例：01背包问题

有编号分别为1,2,3,4的N=4件物品，它们的重量c分别是3, 2, 4, 7，它们的价值p分别是5, 6, 3, 19，每件物品数量只有一个，现在给你个承重为bag=11的背包，如何让背包里装入的物品具有最大的价值总和sum_v？

我们用一张图来看回溯法的执行顺序

代码实现：

	public static int bag01(int[] c, int[] p, int i, int cost, int bag) {
		if (cost > bag) {
			return Integer.MIN_VALUE;
		}
		if (i == c.length) {
			return 0;
		}
		return Math.max(process1(c, p, i + 1, cost, bag), p[i] + process1(c, p, i + 1, cost + c[i], bag));
	}

动态规划

我们来思考一下如何将上面的回溯法改装成动态规划方法

思路：

1. 分析可变参数（解空间，上面的可变参数为：i，cost）
2. 确定最终状态
3. 根据初始状态确定初始值
4. 分析普遍状态依赖哪些位置
5. 根据依赖顺序逆序求整张表

代码如下

	public static int dp(int[] c, int[] p, int bag) {
		int[][] dp = new int[c.length + 1][bag + 1];
		for (int i = c.length - 1; i >= 0; i--) {
			for (int j = bag; j >= 0; j--) {
				dp[i][j] = dp[i + 1][j];
				if (j + c[i] <= bag) {
					dp[i][j] = Math.max(dp[i][j], p[i] + dp[i + 1][j + c[i]]);[j]);
				}
			}
		}
		return dp[0][0];
	}

这个思维仿佛有点奇怪，我们来看一下一个常规解法：

dp的填充步骤可以参考https://blog.csdn.net/likunkun__/article/details/80223003

代码如下

	private static int knapsackProblem(int bag, int[] c, int[] p) {
		int[][] dp = new int[c.length + 1][bag + 1];
		for (int i = 1; i < c.length + 1; i++) {
			for (int j = c[i - 1]; j < bag + 1; j++) {
				System.out.println("i =" + i + " j=" + j);
				dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - c[i - 1]]
						+ p[i - 1]);
			}
		}
		return dp[c.length][bag];
	}

这段代码中，最牛逼的一句话是：

代码中我们可以发现，下一行的值只跟上一行两个值相关，因此我们可以尝试降低时间复杂度

	public static int optimizationdp(int bag, int[] c, int[] p) {
		int[] m = new int[bag + 1];
		for (int i = 1; i < c.length + 1; i++) {
			for (int j = c[i - 1]; j < bag + 1; j++) {
				m[j] = Math.max(m[j - 1], m[j - c[i - 1]] + p[i - 1]);
			}
		}
		return m[bag];
	}

动态规划的基本步骤：

1. 最优子结构性质：找出最优解的性质，并刻画其结构特征；
2. 建立递归关系：递归地定义最优值；
3. 计算最优值：以自底向上的方式计算出最优值；
4. 构造最优解：根据计算最优值时得到的信息，构造最优解。