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) 的最優解 構造出來時，能夠採用動態規劃法，一步步地構造最優解。

      關鍵是掌握動態規劃法求解問題時的分析方法，如何從問題導出 解的遞推式。 實際上，當導出揹包問題的遞歸式後，後來的工做就簡單多了，如何分析揹包問題，導出其最優解的遞推式，我以爲，這纔是最關鍵的地方！問題分析很重要！