0-1背包问题（二维数组动态规划）

1)输出背包的最大价值

/**
 * 0-1背包问题
 * 问题描述
 * 背包的总容量为c, 现有n个物品，每个物品都有其重量w[i],和价值v[i]，求背包能装进的最大价值，以及最大价值时对应的物品
 * 解题思路：
 * 动态规划问题，分别讨论放物品i的时候，背包容量j时的最大价值,当讨论到放最后一个物品时，容量用完的情况，它就是问题的解。因为涉及到2个自变量，所以维护一个二维数组来记录动态规划的每个状态maxV[i][j]
 * 对i j分别讨论就需要循环，循环就需要把问题抽象成一个递推公式，求当前状态的值的时候，可右已经有的状态推出
 * maxV[0][j] = 0 背包不让入任何东西
 * maxV[i][0] = 0 背包容量为0
 * maxV[i][j] =
 * {
 * 	1) maxV[i-1][j] (j < w[i]) 背包的当前容量放不下当前要放的物品是，当前背包容量下要放当前物品的最大价值和前一状态相同,即放前一个物品时当前背包容量的最大价值
 *  2) Max{maxV[i-1][j], v[i]+maxV[i-1][j-w[i]]} (j >= w[i]) 背包的当前容量大于物品的重量，表示当前背包可能放得下当前物品，那么需要分2种情况讨论,
 *  	2.1）不放入当前物品 这种情况很简单，不放的话直接等于放上一个物品的当前容量的最大价值 maxV[i-1][j]
 *  	2.2) 放入当前物品 有点复杂，放进去，总价值肯定有v[i], 然后加上被压缩容量后(j-w[i])的容量状态下，放前一个物品时的最大价值 v[i]+maxV[i-1][j-w[i]]
 * }
 */
package dp;
import java.util.Scanner;
public class Main {
	static int[] w;
	static int[] v;
	static int[][] maxV;
	static int c;
	public static void main(String[] args){
		/**
		 * 测试结果:
		 * 输入：
		 *  10 5
			2 6
			2 3
			6 5
			5 4
			4 6
			输出:
			背包能装最大价值： 15
		 */
		//完成题目条件的输入
		Scanner in = new Scanner(System.in);
		c = in.nextInt();
		int n = in.nextInt();
		w = new int[n+1];
		v = new int[n+1];
		maxV = new int[n+1][c+1];
		while(in.hasNext()){
			for(int i = 1; i <= n; i++){
				w[i] = in.nextInt();
				v[i] = in.nextInt();
			}//输入完成
			//讨论依次放入物品i时，背包容量从1~j的最大价值
			for(int i = 1; i <= n; i++){
				for(int j = 1; j <= c; j++){
					if(j < w[i])
					{
						maxV[i][j] = maxV[i-1][j];//背包容量不支持当前物品，当前容量最大价值等于放上一个物品当前容量的最大价值						
					}
					
					else
					{
						maxV[i][j] = Math.max(maxV[i-1][j], v[i]+maxV[i-1][j-w[i]]);//背包容量支持当前物品，物品可能放入当前背包，去最大情况						
					}
				}
			}
			System.out.println("背包能装最大价值： "+maxV[n][c]);
		}
	}
}

2)依次讨论放第i个物品是时，背包容量为j 的最大价值的数据

当前物品为 1 背包的容量为 1 背包的最大价值为 0

当前物品为 1 背包的容量为2 背包的最大价值为 6

当前物品为 1 背包的容量为3 背包的最大价值为 6

当前物品为 1 背包的容量为4 背包的最大价值为 6

当前物品为 1 背包的容量为5 背包的最大价值为 6

当前物品为 1 背包的容量为6 背包的最大价值为 6

当前物品为 1 背包的容量为7 背包的最大价值为 6

当前物品为 1 背包的容量为8 背包的最大价值为 6

当前物品为 1 背包的容量为9 背包的最大价值为 6

当前物品为 1 背包的容量为10 背包的最大价值为 6

当前物品为 2 背包的容量为 1 背包的最大价值为 0

当前物品为 2 背包的容量为2 背包的最大价值为 6

当前物品为 2 背包的容量为3 背包的最大价值为 6

当前物品为 2 背包的容量为4 背包的最大价值为 9

当前物品为 2 背包的容量为5 背包的最大价值为 9

当前物品为 2 背包的容量为6 背包的最大价值为 9

当前物品为 2 背包的容量为7 背包的最大价值为 9

当前物品为 2 背包的容量为8 背包的最大价值为 9

当前物品为 2 背包的容量为9 背包的最大价值为 9

当前物品为 2 背包的容量为10 背包的最大价值为 9

当前物品为 3 背包的容量为 1 背包的最大价值为 0

当前物品为 3 背包的容量为 2 背包的最大价值为 6

当前物品为 3 背包的容量为 3 背包的最大价值为 6

当前物品为 3 背包的容量为 4 背包的最大价值为 9

当前物品为 3 背包的容量为 5 背包的最大价值为 9

当前物品为 3 背包的容量为6 背包的最大价值为 9

当前物品为 3 背包的容量为7 背包的最大价值为 9

当前物品为 3 背包的容量为8 背包的最大价值为 11

当前物品为 3 背包的容量为9 背包的最大价值为 11

当前物品为 3 背包的容量为10 背包的最大价值为 14

当前物品为 4 背包的容量为 1 背包的最大价值为 0

当前物品为 4 背包的容量为 2 背包的最大价值为 6

当前物品为 4 背包的容量为 3 背包的最大价值为 6

当前物品为 4 背包的容量为 4 背包的最大价值为 9

当前物品为 4 背包的容量为5 背包的最大价值为 9

当前物品为 4 背包的容量为6 背包的最大价值为 9

当前物品为 4 背包的容量为7 背包的最大价值为 10

当前物品为 4 背包的容量为8 背包的最大价值为 11

当前物品为 4 背包的容量为9 背包的最大价值为 13

当前物品为 4 背包的容量为10 背包的最大价值为 14

当前物品为 5 背包的容量为 1 背包的最大价值为 0

当前物品为 5 背包的容量为 2 背包的最大价值为 6

当前物品为 5 背包的容量为 3 背包的最大价值为 6

当前物品为 5 背包的容量为4 背包的最大价值为 9

当前物品为 5 背包的容量为5 背包的最大价值为 9

当前物品为 5 背包的容量为6 背包的最大价值为 12

当前物品为 5 背包的容量为7 背包的最大价值为 12

当前物品为 5 背包的容量为8 背包的最大价值为 15

当前物品为 5 背包的容量为9 背包的最大价值为 15

当前物品为 5 背包的容量为10 背包的最大价值为 15

3）输出放入背包的物品

/**
 * 输出放入背包的所有物品
 * 思路:
 * 当背包的已经有了最大价值时，容量为c,从第n个物品开始往前推，第n个物品是否应该放进去取决于刚进去之后，是否
 * 能创造在j容量下的最大价值，这时会有一个比较，刚进去创造的最大价值和不放进去的最大价值，取最大者。
 * 我们已经知道不放进去的最大价值是maxV[n-1][j],只要当前最大价值大于它，那么就表示第n个物品放进去了，前n-1个物品以此类推
 */
package dp;
import java.util.Scanner;
public class Main {
	static int[] w;
	static int[] v;
	static int[][] maxV;
	static int c;
	public static void main(String[] args){
		/**
		 * 测试结果:
		 * 输入：
		 *  10 5
			2 6
			2 3
			6 5
			5 4
			4 6
			输出:
			背包能装最大价值： 15
			放入的物品编号为: 
			物品编号 5
			物品编号 2
			物品编号 1
		 */
		//完成题目条件的输入
		Scanner in = new Scanner(System.in);
		c = in.nextInt();
		int n = in.nextInt();
		w = new int[n+1];
		v = new int[n+1];
		maxV = new int[n+1][c+1];
		while(in.hasNext()){
			for(int i = 1; i <= n; i++){
				w[i] = in.nextInt();
				v[i] = in.nextInt();
			}//输入完成
			//讨论依次放入物品i时，背包容量从1~j的最大价值
			for(int i = 1; i <= n; i++){
				for(int j = 1; j <= c; j++){
					if(j < w[i])
					{
						maxV[i][j] = maxV[i-1][j];//背包容量不支持当前物品，当前容量最大价值等于放上一个物品当前容量的最大价值						
					}
					
					else
					{
						maxV[i][j] = Math.max(maxV[i-1][j], v[i]+maxV[i-1][j-w[i]]);//背包容量支持当前物品，物品可能放入当前背包，去最大情况						
					}
				}
			}
			System.out.println("背包能装最大价值： "+maxV[n][c]);
			System.out.println("放入的物品编号为: ");
			for(int i = n; i >= 1; i--){
				if(maxV[i][c] > maxV[i-1][c]){
					//第n个物品放进去了
					System.out.println("物品编号 "+i);
					c = c - w[i];
					continue;
					
				}else{
					//第n个物品没有放进去
					continue;
				}
			}
			
		}
	}
}