問題描述：
一個揹包的總容量為V,現在有N類物品,第i類物品的重量為weight[i],價值為value[i]
那麼往該揹包裡裝東西,怎樣裝才能使得最終包內物品的總價值最大。這裡裝物品主要由三種裝法：
1、0-1揹包：每類物品最多隻能裝一次
2、多重揹包：每類物品都有個數限制，第i類物品最多可以裝num[i]次
3、完全揹包：每類物品可以無限次裝進包內

一、0—1揹包
思路分析：
0-1揹包問題主要涉及到兩個問題的求解

a)求解揹包所含物品的最大值：

利用動態規劃求最優值的方法。假設用dp[N][V]來儲存中間狀態值,dp[i][j]表示前i件物品能裝入容量為j的揹包中的物品價值總和的最大值

(注意是最大值),則我們最終只需求知dp[i=N][j=V]的值，即為題目所求。
現在考慮動態規劃陣列dp[i][j]的狀態轉移方程：
假設我們已經求出前i-1件物品裝入容量j的揹包的價值總和最大值為dp[i-1][j],固定容量j的值不變，則對第i件物品的裝法討論如下：
首先第i件物品的重量weight[i]必須小於等於容量j才行，即
1、若weight[i]>j,則第i件物品肯定不能裝入容量為j的揹包，此時dp[i][j]=dp[i-1][j]
2、若weight[i]<=j,則首先明確的是這件物品是可以裝入容量為j的揹包的，那麼如果我們將該物品裝入，則有
dp[i][j]=dp[i-1][j-weight[i]]+value[i]
隨之而來的問題是我們要判斷第i件物品裝到容量為j的揹包後,揹包內的總價值是否是最大？其實很好判斷，即如果裝了第i件物品後的總價值dp[i-1][j-weight[i]]+value[i]>沒裝之前的總價值最大值dp[i-1][j]，則肯是最大的；反之則說明第i件物品不必裝入容量為j的揹包(裝了之後總價值反而變小，那麼肯定就不需要裝嘛)
故，狀態轉移方程如下：
dp[i][j] = (dp[i-1][j] > (dp[i-1][j-weight[i]]+value[i]))? dp[i-1][j]:(dp[i-1][j-weight[i]]+value[i])
注意：這裡的前i件物品是給定次序的

b)求出揹包中裝入物品的編號

這裡我們採用逆推的思路來處理，如果對於dp[i][j]>dp[i-1][j]，則說明第i個物品肯定被放入了揹包，此時我們再考察dp[i-1][j-weight[i]]的編號就可以了。

java程式碼實現：

/**
     * 0-1揹包問題
     * @param V 揹包容量
     * @param N 物品種類
     * @param weight 物品重量
     * @param value 物品價值
     * @return
     */
    public static String ZeroOnePack(int
 
 V,int N,int[] weight,int[] value){

        //初始化動態規劃陣列
        int[][] dp = new int[N+1][V+1];
        //為了便於理解,將dp[i][0]和dp[0][j]均置為0，從1開始計算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大於揹包容量j,則不裝入揹包
                //由於weight和value陣列下標都是從0開始,故注意第i個物品的重量為weight[i-1],價值為value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+value[i-1]);
            }
        }
        //則容量為V的揹包能夠裝入物品的最大值為
        int maxValue = dp[N][V];
        //逆推找出裝入揹包的所有商品的編號
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],這說明第i件物品是放入揹包的
            if(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }
        return numStr;  
    }

0-1揹包的優化解法：

/**
     * 0-1揹包的優化解法
     * 思路：
     * 只用一個一維陣列記錄狀態，dp[i]表示容量為i的揹包所能裝入物品的最大價值
     * 用逆序來實現
     */
    public static int ZeroOnePack2(int V,int N,int[] weight,int[] value){
        //動態規劃
        int[] dp = new int[V+1];
        for(int i=1;i<N+1;i++){
            //逆序實現
            for(int j=V;j>=weight[i-1];j--){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        return dp[V];       
    }

二、多重揹包

java程式碼實現如下：

/**
     * 第三類揹包：多重揹包
     * 
     * @param args
     */
    public static int manyPack(int V,int N,int[] weight,int[] value,int[] num){
        //初始化動態規劃陣列
        int[][] dp = new int[N+1][V+1];
        //為了便於理解,將dp[i][0]和dp[0][j]均置為0，從1開始計算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大於揹包容量j,則不裝入揹包
                //由於weight和value陣列下標都是從0開始,故注意第i個物品的重量為weight[i-1],價值為value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else{
                    //考慮物品的件數限制
                    int maxV = Math.min(num[i-1],j/weight[i-1]);
                    for(int k=0;k<maxV+1;k++){
                        dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-k*weight[i-1]]+k*value[i-1]);
                    }
                }
            }
        }
        /*//則容量為V的揹包能夠裝入物品的最大值為
        int maxValue = dp[N][V];
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],這說明第i件物品是放入揹包的
            while(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }*/
        return dp[N][V];
    }

三、完全揹包

java程式碼實現：

/**
     * 第二類揹包：完全揹包
     * 思路分析：
     * 01揹包問題是在前一個子問題（i-1種物品）的基礎上來解決當前問題（i種物品），
     * 向i-1種物品時的揹包新增第i種物品；而完全揹包問題是在解決當前問題（i種物品）
     * 向i種物品時的揹包新增第i種物品。
     * 推公式計算時，f[i][y] = max{f[i-1][y], (f[i][y-weight[i]]+value[i])}，
     * 注意這裡當考慮放入一個物品 i 時應當考慮還可能繼續放入 i，
     * 因此這裡是f[i][y-weight[i]]+value[i], 而不是f[i-1][y-weight[i]]+value[i]。
     * @param V
     * @param N
     * @param weight
     * @param value
     * @return
     */
    public static String completePack(int V,int N,int[] weight,int[] value){
        //初始化動態規劃陣列
        int[][] dp = new int[N+1][V+1];
        //為了便於理解,將dp[i][0]和dp[0][j]均置為0，從1開始計算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大於揹包容量j,則不裝入揹包
                //由於weight和value陣列下標都是從0開始,故注意第i個物品的重量為weight[i-1],價值為value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-weight[i-1]]+value[i-1]);
            }
        }
        //則容量為V的揹包能夠裝入物品的最大值為
        int maxValue = dp[N][V];
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],這說明第i件物品是放入揹包的
            while(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }
        return numStr;
    }
    /**
     * 完全揹包的第二種解法
     * 思路：
     * 只用一個一維陣列記錄狀態，dp[i]表示容量為i的揹包所能裝入物品的最大價值
     * 用順序來實現
     */
    public static int completePack2(int V,int N,int[] weight,int[] value){

        //動態規劃
        int[] dp = new int[V+1];
        for(int i=1;i<N+1;i++){
            //順序實現
            for(int j=weight[i-1];j<V+1;j++){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        return dp[V];
    }