package com.duoduo.day316;
/**
 * 0-1揹包問題
 * 
 * 問題描述：有n個物品，每個物品的重量為w[i], 價值為v[i]，購物車容量為W，選擇若干個物品放入購物車
 * 限制：在不超過容量的前提下使獲得的價值最大
 * 思路：和之前的貪心演算法（揹包問題）不同，故分析最優子結構後，採用動態規劃思想求解
 * 
 * c[i][j]: 前i件物品放入一個容量為j的購物車可以獲得的最大價值
 *        購物車容量不足，肯定不能放入：
 *       c[i][j]=  c[i-1][j]    j<wi
 *        購物車容量足，看放入，不放入哪種情況獲得的價值最大：
 *       c[i][j]=  max{c[i-1][j],c[i-1][j-w[i]]+v[i]    j>=wi
 *       
 * @author 多多
 *
 */
import  java.util.Scanner;
public class Test4_9 {
	public static void main(String [] args) {
		Scanner sc=new Scanner(System.in);
		System.out.println("請輸入物品的個數n:");
		int n=sc.nextInt();      //物品的個數
		System.out.println("請輸入購物車的容量:");
		int W=sc.nextInt();
		System.out.println("請依次輸入每個物品的重量 w 和價值 v,用空格分開:");
		int [] w=new int[n+1];     //每個物品的重量
		int [] v=new int[n+1];     //每個物品的價值
		for(int i=1;i<=n;i++) {    //存入鍵入的資料
			w[i]=sc.nextInt();
			v[i]=sc.nextInt();
		}
		
		int [][] c=new int[n+1][W+1];  //c[i][j] : 前i件物品放入一個容量為j的購物車可以獲得的最大價值
		//初始化陣列 c[i][j]
		for(int i=0;i<=n;i++)          
			c[i][0]=0;
		for(int j=0;j<=W;j++)
			c[0][j]=0;
		
		/*計算c[i][j]的遞迴式
		購物車容量不足，肯定不能放入：
		        c[i][j]=  c[i-1][j]                j<wi
	        購物車容量足，看放入，不放入哪種情況獲得的價值最大：
		        c[i][j]=  max{c[i-1][j],c[i-1][j-w[i]]+v[i]   j>=wi
		*/
		
		for(int i=1;i<=n;i++) {
			for(int j=1;j<=W;j++) {
				if(j<w[i]) {
					c[i][j]=c[i-1][j];  //購物車容量不足，肯定不能放入：
				}else {
					c[i][j]=max(c[i-1][j],c[i-1][j-w[i]]+v[i]);//購物車容量足，看放入，不放入哪種情況獲得的價值最大：
				}	
			}
		}
		System.out.println("裝入購物車的最大價值："+c[n][W]);
		
		/*逆向構造最優解
		 * 根據c[i][j]陣列的計算結果  逆向  逆推 用一個一維陣列x[]記錄解向量  
		 * x[i]=1  表示第i個物品放入購物車
		 * x[i]=0  表示不放入購物車 
		 * */
		int [] x=new int[n+1];
		int j=W;
		for(int i=n;i>0;i--) {
			if(c[i][j]>c[i-1][j]) {  //說明第i個物品放入購物車 標記為1 且 購物車容量--物品重量
				x[i]=1;
				j-=w[i];
			}else {
				x[i]=0;             //否則 未放入 則標記為0
			}
		}
		
		System.out.println("裝入購物車的物品為:");
		for(int i=1;i<=n;i++) {
			if(x[i]==1)
				System.out.print(i+" ");   //列印標記為1 的物品
		}
	}
	
		

	private static int max(int i, int j) {
		return i>j? i:j ;
	}

}
 

結果：

時間複雜度：主要是兩層巢狀 O(n*W)

空間複雜度：c[n][W]  O(n*W)