算法——背包问题

算法——背包问题

本篇博文通过学习尚硅谷韩老师《数据结构与算法》课程所做，在此非常感谢！

概念

问题

有一个背包，容量为4磅 ， 现有如下物品：

物品	重量	价值
吉他(G)	1	1500
音响(S)	4	3000
电脑©	3	2000

• 要求达到的目标为装入的背包的总价值最大，并且重量不超出;
• 要求装入的物品不能重复;

思路分析

• 背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包(完全背包指的是：每种物品都有无限件可用)；
• 这里的问题属于01背包，即每个物品最多放一个。
• 须知：而无限背包可以转化为01背包(因此这里我们只演示01背包)；

动态规划算法

• 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
• 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
• 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
• 动态规划可以通过填表的方式来逐步推进，得到最优解.

分析

每次遍历到的第i个物品，根据w[i]和v[i]来确定是否需要将该物品放入背包中。即对于给定的n个物品，**设v[i]、w[i]分别为第i个物品的价值和重量，C为背包的容量。再令table[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。**则我们有下面的结果：

• table[i][0] = table[0][j] = 0; (即表示 填入表的第一行和第一列是0)
• 当w[i] > j时：table[i][j]=table[i-1][j] ；(即表示当准备加入新增的商品的容量大于 当前背包的容量时，就直接使用上一个单元格的装入策略)
• 当j>=w[i]时： table[i][j]=max{v[i-1][j], v[i]+table[i-1][j-w[i]]}(当准备加入的新增的商品的容量小于等于当前背包的容量，就选择两变量的最大者)
  • table[i-1][j]： 就是上一个单元格的装入的最大值；
  • v[i]: 表示当前商品的价值 ；
  • table[i-1][j-w[i]] ： 装入第i-1的类型商品到剩余空间j-w[i]的最大值；

代码实现

package edu.hebeu.dynamic_programming;

/**
 * 背包问题
 * 
 * 背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又
 	分`01背包`和`完全背包`(`完全背包`指的是：每种物品都有无限件可用)；这里的问题属于`01背包`，即每个物品最多放一个。

	须知：而`无限背包`可以转化为`01背包`(因此这里我们只演示`01背包`)；

   算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据`w[i]`和`v[i]`来确定是否需要将该物品放入背包中。
   	即对于给定的n个物品，设`v[i]`、`w[i]`分别为第i个物品的价值和重量，C为背包的容量。再令`table[i][j]`表示在前i个物
   	品中能够装入容量为j的背包中的最大价值。则我们有下面的结果：
   		1. `table[i][0] = table[0][j] = 0`; (即表示 填入表的第一行和第一列是0)
		2. 当`w[i] > j`时：`table[i][j]=table[i-1][j]` ；(即表示当准备加入新增的商品的容量大于 当前背包的容量时，就直接使用上一个单元格的装入策略)
		3. 当`j>=w[i]`时： `table[i][j]=max{table[i-1][j], v[i]+table[i-1][j-w[i]]} `(当准备加入的新增的商品的容量小于等于当前背包的容量，就选择两变量的最大者)
	  		3.1. `table[i-1][j]`： 就是上一个单元格的装入的最大值；
	  		3.2. `v[i]`: 表示当前商品的价值 ；
	  		3.3. `table[i-1][j-w[i]]` ： 装入第`i-1`的类型商品到`剩余空间j-w[i]`的最大值；
  
 * 
 * @author 13651
 *
 */
public class Knapsack {

	/**
	 * 存放物品重量的数组
	 */
	private int[] w;
	
	/**
	 * 存放物品价值的数组
	 */
	private int[] v;
	
	/**
	 * 存放物品的数组
	 */
	private String[] goods;
	
	/**
	 * 存放物品种类数量
	 */
	private int goodsNum;
	
	/**
	 * 存放背包问题的填表
	 */
	private int[][] table;
	
	/**
	 * 记录table表的每一项对应的物品(放入背包的物品的组合)情况
	 */
	private int[][] info;
	
	/**
	 * 构造器
	 * @param goods 物品数组
	 * @param w 物品重量的数组
	 * @param v 物品价值的数组
	 * @param capacity 背包的容量
	 */
	public Knapsack(String[] goods, int[] w, int[] v, int capacity) {
		this.goods = goods;
		this.w = w;
		this.v = v;
		goodsNum = goods.length;
		table = new int[goodsNum + 1][capacity + 1];
		info = new int[goodsNum + 1][capacity + 1];
		
		handler();
	}
	
	/**
	 * 填表并得到各种方案的方法
	 */
	private void handler() {
		// TODO 1. `table[i][0] = table[0][j] = 0`; (即表示 填入表的第一行和第一列是0)--------但是不用处理，因为int默认为0
		
		for (int i = 1; i < table.length; i++) { // 从1(第二行)开始处理，即不处理第一行
			for (int j = 1; j < table[0].length; j++) { // 从1(第二列)开始处理，即不处理第一列
				/* TODO 2. 当`w[i] > j`时：`table[i][j] = table[i-1][j]` ；(即表示当准备加入新增的商品的容量大于 当前背包的容量时，就直
				 * 接使用上一个单元格的装入策略)
				 * 
				 * 但是需要注意，因为i和j是从1开始的，因此我们需要进行减1操作，否则就会导致数组的第一个元素无法处理
				 */
				if (w[i - 1] > j) {
					table[i][j] = table[i - 1][j];
				} else {
					/* TODO 3. 当`j >= w[i]`时： `table[i][j] = max{table[i-1][j], v[i] + table[i-1][j-w[i]]} `(当准备加入的新增的商品的容量
					 * 小于等于当前背包的容量，就选择两变量的最大者)
					 * 
					 * 但是需要注意，因为i和j是从1开始的，因此我们需要进行减1操作，否则就会导致数组的第一个元素无法处理
					 */
					if (table[i - 1][j] < v[i - 1] + table[i - 1][j - w[i - 1]]) {
						table[i][j] = v[i - 1] + table[i - 1][j - w[i - 1]];
						// 将当前项的情况记录到info
						info[i][j] = 1;
					} else {
						table[i][j] = table[i - 1][j];
					}
				}
				
			}
		}
	}
	
	/**
	 * 显示填表之后的表
	 */
	public void showTable() {
		for (int i = 0; i < table.length; i++) {
			for (int j = 0; j < table[0].length; j++) {
				System.out.print(table[i][j] + "\t");
			} System.out.println();
		}
	}
	
	/**
	 * 显示填表的表的每一项对应的取值(放入背包的物品)
	 */
	public void showInfo() {
		for (int i = 0; i < info.length; i++) {
			for (int j = 0; j < info[0].length; j++) {
				if (info[i][j] == 1) {
					System.out.print("将物品《" + goods[i - 1] + "》放入坎普斯背包\t");
				}
			} System.out.println();
		}
		
		System.out.print("\n\n=========最优解：");
		int i = info.length - 1; // 获取列(当前的物品)的最大下标
		int j = info[0].length - 1; // 获取行(背包的当前容量)的最大下标
		while (i > 0 && j > 0) { // 从最后开始遍历查找(表的最后是最优解)
			if (info[i][j] == 1) {
				System.out.print("将物品《" + goods[i - 1] + "》放入背包，\t");
				j -= w[i - 1]; // 将背包的容量根据放入的物品做减
			}
			i--; // 进行下一个物品的处理
		}
		System.out.println("此时背包价值：￥" + table[table.length - 1][table[0].length - 1]);
	}

}

测试

测试代码如下：

package edu.hebeu.dynamic_programming;

public class Test {
	public static void main(String[] args) {
		// TODO 物品的数组
		String[] goods = { "40个树枝", "40个草", "3个金币", "40块石头", "2个金块", "一颗紫宝石", "一块月岩" };
		// TODO 物品重量的数组
		int w[] = { 10, 10, 3, 20, 2, 5, 30 };
		// TODO 物品价值的数组
		int val[] = { 1000, 1000, 3000, 2000, 4000, 6000, 10000 };
		// TODO 背包容量
		int capacity = 40;
		
		Knapsack knapsack = new Knapsack(goods, w, val, capacity);
		
		// 显示填表的结果
		knapsack.showTable();
		
		// TODO 显示填表的每一项对应的取值(放入背包的物品)
		knapsack.showInfo();
	}
}