揹包問題主要是指一個給定容量的揹包、若干具有一定價值和重量的物品，如何選擇物品放入揹包使物品的價值最大。其中又分01揹包和無限揹包，這裡主要討論01揹包，即每個物品最多放一個。而無限揹包可以轉化為01揹包。

先說一下演算法的主要思想，利用動態規劃來解決。每次遍歷到的第i個物品，根據w[i]和v[i]來確定是否需要將該物品放入揹包中。即對於給定的n個物品，設v[i]、w[i]分別為第i個物品的價值和重量，C為揹包的容量。再令v[i][j]表示在前i個物品中能夠裝入容量為j的揹包中的最大價值。則我們有下面的結果：

（1），v[i][0]=v[0][j]=0;

（2），v[i][j]=v[i-1][j]   當w[i]>j

（3），v[i][j]=max{v[i-1][j],v[i-1][j-w[i]]+v[i]}  當j>=w[i]

好的，我們的演算法就是基於此三個結論式。

一、01揹包：

1、二維陣列法

public class sf {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] weight = {3,5,2,6,4}; //物品重量
		int[] val = {4,4,3,5,3}; //物品價值
		int m = 12; //揹包容量
		int n = val.length; //物品個數
		
		int[][] f = new int[n+1][m+1]; //f[i][j]表示前i個物品能裝入容量為j的揹包中的最大價值
		int[][] path = new int[n+1][m+1];
		//初始化第一列和第一行
		for(int i=0;i<f.length;i++){
			f[i][0] = 0;
		}
		for(int i=0;i<f[0].length;i++){
			f[0][i] = 0;
		}
		//通過公式迭代計算
		for(int i=1;i<f.length;i++){
			for(int j=1;j<f[0].length;j++){
				if(weight[i-1]>j)
					f[i][j] = f[i-1][j];
				else{
					if(f[i-1][j]<f[i-1][j-weight[i-1]]+val[i-1]){
						f[i][j] = f[i-1][j-weight[i-1]]+val[i-1];
						path[i][j] = 1;
					}else{
						f[i][j] = f[i-1][j];
					}
					//f[i][j] = Math.max(f[i-1][j], f[i-1][j-weight[i-1]]+val[i-1]);
				}
			}
		}
		for(int i=0;i<f.length;i++){
			for(int j=0;j<f[0].length;j++){
				System.out.print(f[i][j]+" ");
			}
			System.out.println();
		}
		
		int i=f.length-1;
		int j=f[0].length-1;
		while(i>0&&j>0){
			if(path[i][j] == 1){
				System.out.print("第"+i+"個物品裝入 ");
				j -= weight[i-1];
			}
			i--;
		}
		
	}

}
 

0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 4 4 4 4 4 4 4 4 4 4 
0 0 0 4 4 4 4 4 8 8 8 8 8 
0 0 3 4 4 7 7 7 8 8 11 11 11 
0 0 3 4 4 7 7 7 8 9 11 12 12 
0 0 3 4 4 7 7 7 8 10 11 12 12 
第4個物品裝入 第3個物品裝入 第1個物品裝入 

以上方法的時間和空間複雜度均為O(N*V)，其中時間複雜度基本已經不能再優化了，但空間複雜度卻可以優化到O(V)。

先考慮上面講的基本思路如何實現，肯定是有一個主迴圈i=1..N，每次算出來二維陣列f[i][0..V]的所有值。那麼，如果只用一個數組

for i=1..N

 for v=V..0

 f[v]=max{f[v],f[v-c[i]]+w[i]};

其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相當於我們的轉移方程f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]}，因為現在的f[v-c[i]]就相當於原來的f[i-1][v-c[i]]。如果將v的迴圈順序從上面的逆序改成順序的話，那麼則成了f[i][v]由f[i][v-c[i]]推知，與本題意不符，但它卻是另一個重要的揹包問題P02最簡捷的解決方案，故學習只用一維陣列解01揹包問題是十分必要的。

我們看到的求最優解的揹包問題題目中，事實上有兩種不太相同的問法。有的題目要求“恰好裝滿揹包”時的最優解，有的題目則並沒有要求必須把揹包裝滿。一種區別這兩種問法的實現方法是在初始化的時候有所不同。

如果是第一種問法，要求恰好裝滿揹包，那麼在初始化時除了f[0]為0其它f[1..V]均設為-∞，這樣就可以保證最終得到的f[N]是一種恰好裝滿揹包的最優解。

如果並沒有要求必須把揹包裝滿，而是隻希望價格儘量大，初始化時應該將f[0..V]全部設為0。

為什麼呢？可以這樣理解：初始化的f陣列事實上就是在沒有任何物品可以放入揹包時的合法狀態。如果要求揹包恰好裝滿，那麼此時只有容量為0的揹包可能被價值為0的nothing“恰好裝滿”，其它容量的揹包均沒有合法的解，屬於未定義的狀態，它們的值就都應該是-∞了。如果揹包並非必須被裝滿，那麼任何容量的揹包都有一個合法解“什麼都不裝”，這個解的價值為0，所以初始時狀態的值也就全部為0了。

2、一維陣列法（無須裝滿）

public class sf {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] weight = {3,5,2,6,4}; //物品重量
		int[] val = {4,4,3,5,3}; //物品價值
		int m = 12; //揹包容量
		int n = val.length; //物品個數
		
		int[] f = new int[m+1];
		for(int i=0;i<f.length;i++){ 	//不必裝滿則初始化為0
			f[i] = 0;
		}
		for(int i=0;i<n;i++){
			for(int j=f.length-1;j>=weight[i];j--){
				f[j] = Math.max(f[j], f[j-weight[i]]+val[i]);
			}
		}
		for(int i=0;i<f.length;i++){
			System.out.print(f[i]+" ");
		}
		System.out.println();
		System.out.println("最大價值為"+f[f.length-1]);
	}
}

0 0 3 4 4 7 7 7 8 9 11 
最大價值為11

3、一維陣列法（必須裝滿）

public class sf {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] weight = {3,5,2,6,4}; //物品重量
		int[] val = {4,4,3,5,3}; //物品價值
		int m = 12; //揹包容量
		int n = val.length; //物品個數
		
		int[] f = new int[m+1];
		for(int i=1;i<f.length;i++){ 	//必裝滿則f[0]=0,f[1...m]都初始化為無窮小
			f[i] = Integer.MIN_VALUE;
		}
		for(int i=0;i<n;i++){
			for(int j=f.length-1;j>=weight[i];j--){
				f[j] = Math.max(f[j], f[j-weight[i]]+val[i]);
			}
		}
		for(int i=0;i<f.length;i++){
			System.out.print(f[i]+" ");
		}
		System.out.println();
		System.out.println("最大價值為"+f[f.length-1]);
	}

}

0 -2147483648 3 4 3 7 6 7 8 10 11 12 11 
最大價值為11

二、完全揹包

有N種物品和一個容量為V的揹包，每種物品都有無限件可用。第i種物品的費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使這些物品的費用總和不超過揹包容量，且價值總和最大。

但我們有更優的O(VN)的演算法。

O(VN)的演算法

這個演算法使用一維陣列，先看虛擬碼：

for i=1..N

 for v=0..V

 f[v]=max{f[v],f[v-cost]+weight}

你會發現，這個虛擬碼與P01的虛擬碼只有v的迴圈次序不同而已。

public class test{
	  public static void main(String[] args){
		   int[] weight = {3,4,6,2,5};
		   int[] val = {6,8,7,5,9};
		   int maxw = 10;
		   int[] f = new int[maxw+1];
		   for(int i=0;i<f.length;i++){
			   f[i] = 0;
		   }
		   for(int i=0;i<val.length;i++){
			   for(int j=weight[i];j<f.length;j++){
				   f[j] = Math.max(f[j], f[j-weight[i]]+val[i]);
			   }
		   }
		   System.out.println(f[maxw]);
	  }
	}

25