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(18)  
  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. }   

限时福利1:原价 129 元,最后2天仅需 69 元!后天涨价至98元 限时福利2:购课进答疑群专享柳峰(刘运强)老师答疑服务 限时福利3:购课添加助教领取价值 800 元的编程大礼包 为什么需要掌握高性能的MySQL实战? 由于互联网产品用户量大、高并发请求场景多,因此对MySQL的性能、可用性、扩展性都提出了很高的要求。使用MySQL解决大量数据以及高并发请求已经是程序员的必备技能,也是衡量一个程序员能力和薪资的标准之一。 为了让大家快速系统了解高性能MySQL核心知识全貌,我为你总结了「高性能 MySQL 知识框架图」,帮你梳理学习重点,建议收藏! 【课程设计】 课程分为四大篇章,将为你建立完整的 MySQL 知识体系,同时将重点讲解 MySQL 底层运行原理、数据库的性能调优、高并发、海量业务处理、面试解析等。 一、性能优化篇: 主要包括经典 MySQL 问题剖析、索引底层原理和事务与锁机制。通过深入理解 MySQL 的索引结构 B+Tree ,学员能够从根本上弄懂为什么有些 SQL 走索引、有些不走索引,从而彻底掌握索引的使用和优化技巧,能够避开很多实战中遇到的“坑”。 二、MySQL 8.0新特性篇: 主要包括窗口函数和通用表表达式。企业中的许多报表统计需求,如果不采用窗口函数,用普通的 SQL 语句是很难实现的。 三、高性能架构篇: 主要包括主从复制和读写分离。在企业的生产环境中,很少采用单台MySQL节点的情况,因为一旦单个节点发生故障,整个系统都不可用,后果往往不堪设想,因此掌握高可用架构的实现是非常有必要的。 四、面试篇: 程序员获得工作的第一步,就是高效的准备面试,面试篇主要从知识点回顾总结的角度出发,结合程序员面试高频MySQL问题精讲精练,帮助程序员吊打面试官,获得心仪的工作机会。
©️2020 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页