Java實現動態規划法求解0/1背包問題

     摘要： 使用動態規划法求解0/1背包問題。

     難度： 初級 

 

      0/1背包問題的動態規划法求解，前人之述備矣，這里所做的工作，不過是自己根據理解實現了一遍，主要目的還是鍛煉思維和編程能力，同時，也是為了增進對動態規划法機制的理解和掌握。 

      值得提及的一個問題是，在用 JAVA 實現時， 是按算法模型建模，還是用對象模型建模呢？ 如果用算法模型，那么 背包的值、重量就直接存入二個數組里；如果用對象模型，則要對背包以及背包問題進行對象建模。思來想去，還是采用了對象模型，盡管心里感覺算法模型似乎更好一些。有時確實就是這樣，對象模型雖然現在很主流，但也不是萬能的，采用其它的模型和視角，或許可以得到更好的解法。

 

     背包建模：     

package algorithm.dynamicplan;
public class Knapsack {
    
    /** 背包重量  */
    private int weight;
    
    /** 背包物品價值  */
    private int value;
    /***
     * 構造器
     */
    public Knapsack(int weight, int value) {
        this.value = value;
        this.weight = weight;
    }
    public int getWeight() {
        return weight;
    }
    
    public int getValue() {
        return value;
    }
    
    public String toString() {
        return "[weight: " + weight + " " + "value: " + value + "]";  
    }
} 

 

　　背包問題求解：

      

/**
 * 求解背包問題：
 * 給定 n 個背包，其重量分別為 w1,w2,……,wn, 價值分別為 v1,v2,……,vn
 * 要放入總承重為 totalWeight 的箱子中， 
 * 求可放入箱子的背包價值總和的最大值。
 * 
 * NOTE: 使用動態規划法求解 背包問題
 * 設 前 n 個背包，總承重為 j 的最優值為 v[n,j], 最優解背包組成為 b[n];
 * 求解最優值：
 * 1. 若 j < wn, 則 ： v[n,j] = v[n-1,j];
 * 2. 若  j >= wn, 則：v[n,j] = max{v[n-1,j], vn + v[n-1,j-wn]}。
 * 
 * 求解最優背包組成：
 * 1. 若 v[n,j] > v[n-1,j] 則 背包 n 被選擇放入 b[n], 
 * 2. 接着求解前 n-1 個背包放入 j-wn 的總承重中， 
 *    於是應當判斷 v[n-1, j-wn] VS v[n-2,j-wn], 決定 背包 n-1 是否被選擇。
 * 3. 依次逆推，直至總承重為零。
 *    
 *    重點： 掌握使用動態規划法求解問題的分析方法和實現思想。
 *    分析方法： 問題實例 P(n) 的最優解S(n) 蘊含 問題實例 P(n-1) 的最優解S(n-1);
 *              在S(n-1)的基礎上構造 S(n) 
 *    實現思想： 自底向上的迭代求解 和 基於記憶功能的自頂向下遞歸
 */
package algorithm.dynamicplan;
import java.util.ArrayList;
public class KnapsackProblem {
    
    /** 指定背包 */
    private Knapsack[] bags;
    
    /** 總承重  */
    private int totalWeight;
    
    /** 給定背包數量  */
    private int n;
    
    /** 前 n 個背包，總承重為 totalWeight 的最優值矩陣  */
    private int[][] bestValues;
    
    /** 前 n 個背包，總承重為 totalWeight 的最優值 */
    private int bestValue;
    
    /** 前 n 個背包，總承重為 totalWeight 的最優解的物品組成 */
    private ArrayList<Knapsack> bestSolution;
    
    public KnapsackProblem(Knapsack[] bags, int totalWeight) {
        this.bags = bags;
        this.totalWeight = totalWeight;
        this.n = bags.length;
        if (bestValues == null) {
            bestValues = new int[n+1][totalWeight+1];
        }
    }
    
    /**
     * 求解前 n 個背包、給定總承重為 totalWeight 下的背包問題
     * 
     */
    public void solve() {
        
        System.out.println("給定背包：");
        for(Knapsack b: bags) {
            System.out.println(b);
        }
        System.out.println("給定總承重: " + totalWeight);
        
        // 求解最優值
        for (int j = 0; j <= totalWeight; j++) {
            for (int i = 0; i <= n; i++) {
            
                if (i == 0 || j == 0) {
                    bestValues[i][j] = 0;
                }    
                else 
                {
                    // 如果第 i 個背包重量大於總承重，則最優解存在於前 i-1 個背包中，
                    // 注意：第 i 個背包是 bags[i-1]
                    if (j < bags[i-1].getWeight()) {
                        bestValues[i][j] = bestValues[i-1][j];
                    }    
                    else 
                    {
                        // 如果第 i 個背包不大於總承重，則最優解要么是包含第 i 個背包的最優解，
                        // 要么是不包含第 i 個背包的最優解， 取兩者最大值，這里采用了分類討論法
                        // 第 i 個背包的重量 iweight 和價值 ivalue
                        int iweight = bags[i-1].getWeight();
                        int ivalue = bags[i-1].getValue();
                        bestValues[i][j] = 
                            Math.max(bestValues[i-1][j], ivalue + bestValues[i-1][j-iweight]);        
                    } // else
                } //else         
           } //for
        } //for
        
        // 求解背包組成
        if (bestSolution == null) {
            bestSolution = new ArrayList<Knapsack>();
        }
        int tempWeight = totalWeight;
        for (int i=n; i >= 1; i--) {
           if (bestValues[i][tempWeight] > bestValues[i-1][tempWeight]) {
               bestSolution.add(bags[i-1]);  // bags[i-1] 表示第 i 個背包
               tempWeight -= bags[i-1].getWeight();
           }
           if (tempWeight == 0) { break; }
        }
        bestValue = bestValues[n][totalWeight];
       }
    
    /**
     * 獲得前  n 個背包， 總承重為 totalWeight 的背包問題的最優解值
     * 調用條件： 必須先調用 solve 方法
     * 
     */
    public int getBestValue() {    
        return bestValue;
    }
    
    /**
     * 獲得前  n 個背包， 總承重為 totalWeight 的背包問題的最優解值矩陣
     * 調用條件： 必須先調用 solve 方法
     * 
     */
    public int[][] getBestValues() {
        
        return bestValues;
    }
    
    /**
     * 獲得前  n 個背包， 總承重為 totalWeight 的背包問題的最優解值矩陣
     * 調用條件： 必須先調用 solve 方法
     * 
     */
    public ArrayList<Knapsack> getBestSolution() {
        return bestSolution;
    }
    
}

 

　　背包問題測試：

      

package algorithm.dynamicplan;

public class KnapsackTest {
    
    public static void main(String[] args) {
        
        Knapsack[] bags = new Knapsack[] {
                new Knapsack(2,13), new Knapsack(1,10),
                new Knapsack(3,24), new Knapsack(2,15),
                new Knapsack(4,28), new Knapsack(5,33),
                new Knapsack(3,20), new Knapsack(1, 8)
        };
        int totalWeight = 12;
        KnapsackProblem kp = new KnapsackProblem(bags, totalWeight);
        
        kp.solve();
        System.out.println(" -------- 該背包問題實例的解: --------- ");
        System.out.println("最優值：" + kp.getBestValue());    
        System.out.println("最優解【選取的背包】: ");
        System.out.println(kp.getBestSolution());
        System.out.println("最優值矩陣：");
        int[][] bestValues = kp.getBestValues();
        for (int i=0; i < bestValues.length; i++) {
            for (int j=0; j < bestValues[i].length; j++) {
                System.out.printf("%-5d", bestValues[i][j]);
            }
            System.out.println();
        }
    }
} 

　　

動態規划法總結：

1. 動態規划法用於求解非最優化問題：

當問題實例P(n)的解由子問題實例的解構成時，比如 P(n) = P(n-1) + P(n-2) [斐波那契數列] ，而 P(n-1) 和 P(n-2)可能包含重合的子問題，可以使用動態規划法，通過自底向上的迭代，求解較小子問題實例的解，並作為求解較大子問題實例的解的基礎。關鍵思想是： 避免對子問題重復求解。

比如： 求斐波那契數 F(5)：

F(5)  = F(4) + F(3);

子問題： F(4) = F(3) + F(2) ;

                        F(3) = F(2) + F(1);

                                  F(2) = F(1) + F(0)

                        F(2) = F(1) + F(0);

子問題： F(3) = F(2) + F(1)

                        F(2) = F(1) + F(0)

由上面的計算過程可知，如果單純使用遞歸式，則子問題 F(2) 被重復計算了2次；當問題實例較大時，這些重復的子問題求解就會耗費大量不必要的時間。 若使用動態規划法，將 F(2) 的值存儲起來，當后續計算需要的時候，直接取出來， 就可以節省不少時間。

 

另一個比較典型的例子是： 求解二項式系數  C(n, k) = C(n-1, k) + C(n-1, k-1)

 

2. 動態規划法求解最優化問題：

      當問題實例P(n) 的最優解 可以從 問題實例 P(n-1) 的最優解 構造出來時，可以采用動態規划法，一步步地構造最優解。

      關鍵是掌握動態規划法求解問題時的分析方法，如何從問題導出 解的遞推式。 實際上，當導出背包問題的遞歸式后，后來的工作就簡單多了，如何分析背包問題，導出其最優解的遞推式，我覺得，這才是最關鍵的地方！問題分析很重要！