動態規划算法之0-1背包問題

一、問題描述：有n 個物品，它們有各自的重量和價值，現有給定容量的背包，如何讓背包里裝入的物品具有最大的價值總和？

二、總體思路：根據動態規划解題步驟（問題抽象化、建立模型、尋找約束條件、判斷是否滿足最優性原理、找大問題與小問題的遞推關系式、填表、尋找解組成）找出01背包問題的最優解以及解組成；

三、動態規划的原理及過程：

　　eg：number＝4，capacity＝8

i	1	2	3	4
w(體積)	2	3	4	5
v(價值)	3	4	5	6

 

1、原理

　　動態規划與分治法類似，都是把大問題拆分成小問題，通過尋找大問題與小問題的遞推關系，解決一個個小問題，最終達到解決原問題的效果。但不同的是，分治法在子問題和子子問題等上被重復計算了很多次，而動態規划則具有記憶性，通過填寫表把所有已經解決的子問題答案紀錄下來，在新問題里需要用到的子問題可以直接提取，避免了重復計算，從而節約了時間，所以在問題滿足最優性原理之后，用動態規划解決問題的核心就在於填表，表填寫完畢，最優解也就找到。

2、過程

　　a) 把背包問題抽象化（X₁，X_2，…，Xn，其中 Xi 取0或1，表示第 i 個物品選或不選），V_i表示第 i 個物品的價值，W_i表示第 i 個物品的體積（重量）；

　　b) 建立模型，即求max(V₁X₁+V₂X₂+…+VnXn)；

　　c) 約束條件，W₁X₁+W₂X₂+…+WnXn<capacity；

　　d) 定義V(i,j)：當前背包容量 j，前 i 個物品最佳組合對應的價值；

　　e) 最優性原理是動態規划的基礎，最優性原理是指“多階段決策過程的最優決策序列具有這樣的性質：不論初始狀態和初始決策如何，對於前面決策所造成的某一狀態而言，其后各階段的決策序列必須構成最優策略”。判斷該問題是否滿足最優性原理，采用反證法證明：

　　　　假設(X₁，X₂，…，Xn)是01背包問題的最優解，則有(X₂，X₃，…，Xn)是其子問題的最優解，

　　　　假設(Y₂，Y_3，…，Yn)是上述問題的子問題最優解，則理應有(V₂Y₂+V₃Y₃+…+VnYn)+V₁X₁ > (V₂X₂+V₃X₃+…+VnXn)+V₁X_1；

　　　　而(V₂X₂+V₃X₃+…+VnXn)+V₁X₁=(V₁X₁+V₂X₂+…+VnXn)，則有(V₂Y₂+V₃Y₃+…+VnYn)+V₁X₁ > (V₁X₁+V₂X₂+…+VnXn)；

　　　　該式子說明(X₁，Y₂，Y_3，…，Yn)才是該01背包問題的最優解，這與最開始的假設(X₁，X₂，…，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；

 

　　h) 然后一行一行的填表，

　　　　1) 如，i=1，j=1，w(1)=2，v(1)=3，有j<w(1)，故V(1,1)=V(1-1,1)=0；

　　　　2) 又如i=1，j=2，w(1)=2，v(1)=3，有j=w(1),故V(1,2)=max｛ V(1-1,2)，V(1-1,2-w(1))+v(1) ｝=max｛0，0+3｝=3；

　　　　3) 如此下去，填到最后一個，i=4，j=8，w(4)=5，v(4)=6，有j>w(4)，故V(4,8)=max｛ V(4-1,8)，V(4-1,8-w(4))+v(4) ｝=max｛9，4+6｝=10；所以填完表如下圖：

 

　　i) 表格填完，最優解即是V(number,capacity)=V(4,8)=10，但還不知道解由哪些商品組成，故要根據最優解回溯找出解的組成，根據填表的原理可以有如下的尋解方式：

　　　　1) V(i,j)=V(i-1,j)時，說明沒有選擇第i 個商品，則回到V(i-1,j)；

　　　　2) V(i,j)=V(i-1,j-w(i))+v(i)實時，說明裝了第i個商品，該商品是最優解組成的一部分，隨后我們得回到裝該商品之前，即回到V(i-1,j-w(i))；

　　　　3) 一直遍歷到i＝0結束為止，所有解的組成都會找到。

　　j) 如上例子，

　　　　1) 最優解為V(4,8)=10，而V(4,8)!=V(3,8)卻有V(4,8)=V(3,8-w(4))+v(4)=V(3,3)+6=4+6=10，所以第4件商品被選中，並且回到V(3,8-w(4))=V(3,3)；

　　　　2) 有V(3,3)=V(2,3)=4，所以第3件商品沒被選擇，回到V(2,3)；

　　　　3) 而V(2,3)!=V(1,3)卻有V(2,3)=V(1,3-w(2))+v(2)=V(1,0)+4=0+4=4，所以第2件商品被選中，並且回到V(1,3-w(2))=V(1,0)；

　　　　4) 有V(1,0)=V(0,0)=0，所以第1件商品沒被選擇；

 

　　k) 到此，01背包問題已經解決，利用動態規划解決此問題的效率即是填寫此張表的效率，所以動態規划的時間效率為O(number*capacity)=O(n*c)，由於用到二維數組存儲子問題的解，所以動態規划的空間效率為O(n*c)；

       L)程序實現：

import java.util.Scanner;  
public class Main {  
    
    public static void zeroOnePack(){
        Scanner scanner = new Scanner(System.in);
        String packInfo = null;
        String weights = null;
        String values = null;
        while(scanner.hasNextLine()){
            packInfo = scanner.nextLine();
            int packageWeight = Integer.valueOf(packInfo.split(" ")[0]);
            int numbers = Integer.valueOf(packInfo.split(" ")[1]);
            
            weights = scanner.nextLine();
            values = scanner.nextLine();
            String[] weis = weights.split(" ");
            String[] vals = values.split(" ");
            //weight[]數組是從下標0開始存儲，索引0存儲第一件物品的重量
            int[] weight = new int[numbers];
            int[] value = new int[numbers];
            
            for(int i = 0; i < numbers; i++)
            {
                weight[i] = Integer.valueOf(weis[i]);
                value[i] = Integer.valueOf(vals[i]);
            }
            
            int[][] dp = new int[numbers + 1][packageWeight + 1];
            
            //init
            for(int i = 0; i <= numbers; i++)
                dp[i][0] = 0;
            for(int i = 0; i <= packageWeight; i++)
                dp[0][i] = 0;
        
            //dp[i][j] = max{dp[i-1][j], dp[i-1][j-weight[i-1]]+value[i-1]}
            for(int i = 1; i <= numbers; i++)
            {
                for(int j = 1; j <= packageWeight; j++)
                {
                    if(weight[i-1] > j)// 第i件物品的重量大於背包的承重
                
                    {
                        dp[i][j] = dp[i-1][j];
                        continue;
                    }
                    //dp[i][j] = max{dp[i-1][j], dp[i-1][j-weight[i-1]]+value[i-1]}
                    if(dp[i-1][j] < dp[i-1][j-weight[i-1]] + value[i-1])
                        dp[i][j] = dp[i-1][j-weight[i-1]] + value[i-1];
                    else
                        dp[i][j] = dp[i-1][j];
                }
            }
            System.out.println(dp[numbers][packageWeight]);//輸出背包能夠裝的最大價值
            
            //反向找出 選中的物品(哪些物品裝入到背包中了?)
            int j= packageWeight;  
            for(int i = numbers;i>0;i--){
                if(dp[i][j]>dp[i-1][j]){
                    System.out.print(i+"  ");//輸出選中的物品的編號
                    j=j-weight[i-1];
                    if(j<0) break;
                }  
        }//end while
    }  
        scanner.close();
}
    // test case
    //10 5
    //2 2 6 5 4
    //6 3 5 4 6
    public static void main(String[] args) {
        zeroOnePack();
    }
}

       M）運行結果：

 由結果可知，最大價值是15，選取的物品是第1，2，5件

參考文獻：王曉東《算法設計與分析》

                   https://www.cnblogs.com/hapjin/p/5818418.html

                   https://www.cnblogs.com/Christal-R/p/Dynamic_programming.html（總結的很好）