动态规划：01背包

01背包解决的问题是，当存在N个物品，且每个物品的重量为w[i]，价值v[i]，现存在一个包裹体积为capacity，那么如何放置物品可是包裹的价值最大。

这里有一篇详细的参考文章：

https://www.cnblogs.com/Christal-R/p/Dynamic_programming.html

首先这里有一个递推关系式，Val[i][j]指的是物品 i 放在容量只剩下 j 的包里时，包的总价值，Val[i][j] = max{Val[i-1][j],Val[i-1][j-w[i]+v[i]} ,也就是放入和不放入时谁比较大，默认前i-1的为最优解。（注意看上篇文章的递推公式），算了，我截个图，以免忘记了。

2、过程

　　a) 把背包问题抽象化（X1，X2，…，Xn，其中 Xi 取0或1，表示第 i 个物品选或不选），Vi表示第 i 个物品的价值，Wi表示第 i 个物品的体积（重量）；

　　b) 建立模型，即求max(V1X1+V2X2+…+VnXn)；

　　c) 约束条件，W1X1+W2X2+…+WnXn<capacity；

　　d) 定义V(i,j)：当前背包容量 j，前 i 个物品最佳组合对应的价值；

　　e) 最优性原理是动态规划的基础，最优性原理是指“多阶段决策过程的最优决策序列具有这样的性质：不论初始状态和初始决策如何，对于前面决策所造成的某一状态而言，其后各阶段的决策序列必须构成最优策略”。判断该问题是否满足最优性原理，采用反证法证明：

　　　　假设(X1，X2，…，Xn)是01背包问题的最优解，则有(X2，X3，…，Xn)是其子问题的最优解，

　　　　假设(Y2，Y3，…，Yn)是上述问题的子问题最优解，则理应有(V2Y2+V3Y3+…+VnYn)+V1X1 > (V2X2+V3X3+…+VnXn)+V1X1；

　　　　而(V2X2+V3X3+…+VnXn)+V1X1=(V1X1+V2X2+…+VnXn)，则有(V2Y2+V3Y3+…+VnYn)+V1X1 > (V1X1+V2X2+…+VnXn)；

　　　　该式子说明(X1，Y2，Y3，…，Yn)才是该01背包问题的最优解，这与最开始的假设(X1，X2，…，Xn)是01背包问题的最优解相矛盾，故01背包问题满足最优性原理；

　　f) 寻找递推关系式，面对当前商品有两种可能性：

　　　　第一，包的容量比该商品体积小，装不下，此时的价值与前i-1个的价值是一样的，即V(i,j)=V(i-1,j)；

　　　　第二，还有足够的容量可以装该商品，但装了也不一定达到当前最优价值，所以在装与不装之间选择最优的一个，即V(i,j)=max｛ V(i-1,j)，V(i-1,j-w(i))+v(i) ｝

　　　　　　　其中V(i-1,j)表示不装，V(i-1,j-w(i))+v(i) 表示装了第i个商品，背包容量减少w(i)但价值增加了v(i)；

　　　　由此可以得出递推关系式：

　　　　1) j<w(i)      V(i,j)=V(i-1,j)

　　　　2) j>=w(i)     V(i,j)=max｛ V(i-1,j)，V(i-1,j-w(i))+v(i) ｝

　　g) 填表，首先初始化边界条件，V(0,j)=V(i,0)=0；

 

下面为可直接执行的代码：

package dyfu.algorithm;

import java.util.Scanner;

public class DynamicProgram_01Bag {
	
	//物品体积数组
	public static int[] setWArray(int len) {
		return new int[len];
	}
	
	//物品价值数组
	public static int[] setVArrary(int len) {
		return new int[len];
	}
	
	//在背包剩余体积为j时，放入第i件物品时的价值V[i][j]
	public static int[][] setVal(int i,int j) {
		return new int[i][j];
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);	//以tab space enter键为结束符
		
		System.out.println("输入背包的体积：");
		int capacity = scan.nextInt();
		
		System.out.println("输入物品个数：");
		int amount = scan.nextInt();
		
		int w[] = setWArray(amount+1);	//物品体积
		w[0]=0;
		int v[] = setVArrary(amount+1);	//物品价值
		v[0]=0;
		System.out.println("输入每个物品的体积，以空格分隔：");
		int i=1,j=1;
		scan.nextLine();	//此处读取nextInt的换行符
		String[] wtmp = scan.nextLine().split(" ");
		for(String s : wtmp) {
			w[i]=new Integer(s);
			i++;
		}
		
		System.out.println("输入每个物品的价值，以空格分隔：");
		String[] vtmp = scan.nextLine().split(" ");
		for(String str : vtmp) {
			v[j] = new Integer(str);
			j++;
		}
		scan.close();
		int [][] Val = setVal(amount+1, capacity+1);	//背包总价值
		
		//解法一：时间复杂度为O(amount*capacity),空间复杂度为O(amount*capacity),此方法可以回朔得到具体
		//在体积为capacity时，能放入的最大价值的具体物品是谁
		//第一行第一列置0
		for(int x=0;x<=amount;x++)
			Val[x][0] = 0;
		for(int y=0;y<=capacity;y++) 
			Val[0][y] = 0;
		
		for(i=1;i<=amount;i++) {
			for(j=1;j<=capacity;j++) {
				if(j<w[i]) {
					Val[i][j] = Val[i-1][j];
				}else {
					if(Val[i-1][j] > Val[i-1][j-w[i]]+v[i]) {
						Val[i][j] = Val[i-1][j] ;	//不装入比较大
					}else {
						Val[i][j] = Val[i-1][j-w[i]]+v[i];
						//System.out.println("Val["+i+"]["+j+"]="+Val[i][j]);
					}
				}
			}
		}
		
		System.out.println("背包客装入的最大价值："+Val[amount][capacity]);
		getPerfactId(Val,w,amount,capacity,v);
		
		/*//解法二：降低了空间复杂度
		for(i 1..amount)
			for(j capacity..1) {
				B[j] = max{B[j],B[j-w(i)]+v(i)}
			}
		*/
	}
	
	//解法一对应的最优物品Id
	public static void getPerfactId(int [][] Val , int w[] , int i , int j,int v[]) {
		int k = i;
		int z = j;
		while(k>0) {
			if(Val[k-1][z]==Val[k][z]) {
				k = k-1;
			}else if(z-w[k]>=0 && Val[k][z]==Val[k-1][z-w[k]]+v[k]) {
				System.out.print(k+" ");
				z=z-w[k];
				k = k-1;
			}
		}	
	}

}

使用此数据：

 

运行结果为：