0/1背包问题的动态规划法求解 —— Java 实现

 0/1背包问题的动态规划法求解，前人之述备矣，这里所做的工作，不过是自己根据理解实现了一遍，主要目的还是锻炼思维和编程能力，同时，也是为了增进对动态规划法机制的理解和掌握。 

      值得提及的一个问题是，在用 JAVA 实现时， 是按算法模型建模，还是用对象模型建模呢？ 如果用算法模型，那么 背包的值、重量就直接存入二个数组里；如果用对象模型，则要对背包以及背包问题进行对象建模。思来想去，还是采用了对象模型，尽管心里感觉算法模型似乎更好一些。有时确实就是这样，对象模型虽然现在很主流，但也不是万能的，采用其它的模型和视角，或许可以得到更好的解法。

首先是问题描述：给定n种物品和一背包，物品i的重量是wi，其价值是pi，背包的容量是M，问如何选择装入背包中的物品总价值最大

下面是思路的基本过程

问题的特点是：每种物品一件，可以选择放1或不放0。

用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：

f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

方程的含义：“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

背包建模：

[java]  view plain copy print ?

1. package algorithm.dynamicplan;  
2. public class Knapsack {  
3.       
4.     /** 背包重量  */  
5.     private int weight;  
6.       
7.     /** 背包物品价值  */  
8.     private int value;  
9.     /*** 
10.      * 构造器 
11.      */  
12.     public Knapsack(int weight, int value) {  
13.         this.value = value;  
14.         this.weight = weight;  
15.     }  
16.     public int getWeight() {  
17.         return weight;  
18.     }  
19.       
20.     public int getValue() {  
21.         return value;  
22.     }  
23.       
24.     public String toString() {  
25.         return "[weight: " + weight + " " + "value: " + value + "]";    
26.     }  
27. }   

 

背包问题求解：

[java]  view plain copy print ?

1. /** 
2.  * 求解背包问题： 
3.  * 给定 n 个背包，其重量分别为 w1,w2,……,wn, 价值分别为 v1,v2,……,vn 
4.  * 要放入总承重为 totalWeight 的箱子中，  
5.  * 求可放入箱子的背包价值总和的最大值。 
6.  *  
7.  * NOTE: 使用动态规划法求解 背包问题 
8.  * 设 前 n 个背包，总承重为 j 的最优值为 v[n,j], 最优解背包组成为 b[n]; 
9.  * 求解最优值： 
10.  * 1. 若 j < wn, 则 ： v[n,j] = v[n-1,j]; 
11.  * 2. 若  j >= wn, 则：v[n,j] = max{v[n-1,j], vn + v[n-1,j-wn]}。 
12.  *  
13.  * 求解最优背包组成： 
14.  * 1. 若 v[n,j] > v[n-1,j] 则 背包 n 被选择放入 b[n],  
15.  * 2. 接着求解前 n-1 个背包放入 j-wn 的总承重中，  
16.  *    于是应当判断 v[n-1, j-wn] VS v[n-2,j-wn], 决定 背包 n-1 是否被选择。 
17.  * 3. 依次逆推，直至总承重为零。 
18.  *     
19.  *    重点： 掌握使用动态规划法求解问题的分析方法和实现思想。 
20.  *    分析方法： 问题实例 P(n) 的最优解S(n) 蕴含 问题实例 P(n-1) 的最优解S(n-1); 
21.  *              在S(n-1)的基础上构造 S(n)  
22.  *    实现思想： 自底向上的迭代求解 和 基于记忆功能的自顶向下递归 
23.  */  
24. package algorithm.dynamicplan;  
25. import java.util.ArrayList;  
26. public class KnapsackProblem {  
27.       
28.     /** 指定背包 */  
29.     private Knapsack[] bags;  
30.       
31.     /** 总承重  */  
32.     private int totalWeight;  
33.       
34.     /** 给定背包数量  */  
35.     private int n;  
36.       
37.     /** 前 n 个背包，总承重为 totalWeight 的最优值矩阵  */  
38.     private int[][] bestValues;  
39.       
40.     /** 前 n 个背包，总承重为 totalWeight 的最优值 */  
41.     private int bestValue;  
42.       
43.     /** 前 n 个背包，总承重为 totalWeight 的最优解的物品组成 */  
44.     private ArrayList<Knapsack> bestSolution;  
45.       
46.     public KnapsackProblem(Knapsack[] bags, int totalWeight) {  
47.         this.bags = bags;  
48.         this.totalWeight = totalWeight;  
49.         this.n = bags.length;  
50.         if (bestValues == null) {  
51.             bestValues = new int[n+1][totalWeight+1];  
52.         }  
53.     }  
54.       
55.     /** 
56.      * 求解前 n 个背包、给定总承重为 totalWeight 下的背包问题 
57.      *  
58.      */  
59.     public void solve() {  
60.           
61.         System.out.println("给定背包：");  
62.         for(Knapsack b: bags) {  
63.             System.out.println(b);  
64.         }  
65.         System.out.println("给定总承重: " + totalWeight);  
66.           
67.         // 求解最优值  
68.         for (int j = 0; j <= totalWeight; j++) {  
69.             for (int i = 0; i <= n; i++) {  
70.               
71.                 if (i == 0 || j == 0) {  
72.                     bestValues[i][j] = 0;  
73.                 }     
74.                 else   
75.                 {  
76.                     // 如果第 i 个背包重量大于总承重，则最优解存在于前 i-1 个背包中，  
77.                     // 注意：第 i 个背包是 bags[i-1]  
78.                     if (j < bags[i-1].getWeight()) {  
79.                         bestValues[i][j] = bestValues[i-1][j];  
80.                     }     
81.                     else   
82.                     {  
83.                         // 如果第 i 个背包不大于总承重，则最优解要么是包含第 i 个背包的最优解，  
84.                         // 要么是不包含第 i 个背包的最优解， 取两者最大值，这里采用了分类讨论法  
85.                         // 第 i 个背包的重量 iweight 和价值 ivalue  
86.                         int iweight = bags[i-1].getWeight();  
87.                         int ivalue = bags[i-1].getValue();  
88.                         bestValues[i][j] =   
89.                             Math.max(bestValues[i-1][j], ivalue + bestValues[i-1][j-iweight]);        
90.                     } // else  
91.                 } //else           
92.            } //for  
93.         } //for  
94.           
95.         // 求解背包组成  
96.         if (bestSolution == null) {  
97.             bestSolution = new ArrayList<Knapsack>();  
98.         }  
99.         int tempWeight = totalWeight;  
100.         for (int i=n; i >= 1; i--) {  
101.            if (bestValues[i][tempWeight] > bestValues[i-1][tempWeight]) {  
102.                bestSolution.add(bags[i-1]);  // bags[i-1] 表示第 i 个背包  
103.                tempWeight -= bags[i-1].getWeight();  
104.            }  
105.            if (tempWeight == 0) { break; }  
106.         }  
107.         bestValue = bestValues[n][totalWeight];  
108.     }  
109.       
110.     /** 
111.      * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值 
112.      * 调用条件： 必须先调用 solve 方法 
113.      *  
114.      */  
115.     public int getBestValue() {   
116.         return bestValue;  
117.     }  
118.       
119.     /** 
120.      * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值矩阵 
121.      * 调用条件： 必须先调用 solve 方法 
122.      *  
123.      */  
124.     public int[][] getBestValues() {  
125.           
126.         return bestValues;  
127.     }  
128.       
129.     /** 
130.      * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值矩阵 
131.      * 调用条件： 必须先调用 solve 方法 
132.      *  
133.      */  
134.     public ArrayList<Knapsack> getBestSolution() {  
135.         return bestSolution;  
136.     }  
137.       
138. }  

 

背包问题测试：

[java]  view plain copy print ?

1. package algorithm.dynamicplan;  
2.   
3. public class KnapsackTest {  
4.       
5.     public static void main(String[] args) {  
6.           
7.         Knapsack[] bags = new Knapsack[] {  
8.                 new Knapsack(2,13), new Knapsack(1,10),  
9.                 new Knapsack(3,24), new Knapsack(2,15),  
10.                 new Knapsack(4,28), new Knapsack(5,33),  
11.                 new Knapsack(3,20), new Knapsack(1, 8)  
12.         };  
13.         int totalWeight = 12;  
14.         KnapsackProblem kp = new KnapsackProblem(bags, totalWeight);  
15.           
16.         kp.solve();  
17.         System.out.println(" -------- 该背包问题实例的解: --------- ");  
18.         System.out.println("最优值：" + kp.getBestValue());   
19.         System.out.println("最优解【选取的背包】: ");  
20.         System.out.println(kp.getBestSolution());  
21.         System.out.println("最优值矩阵：");  
22.         int[][] bestValues = kp.getBestValues();  
23.         for (int i=0; i < bestValues.length; i++) {  
24.             for (int j=0; j < bestValues[i].length; j++) {  
25.                 System.out.printf("%-5d", bestValues[i][j]);  
26.             }  
27.             System.out.println();  
28.         }  
29.     }  
30. }