【转】经典算法:背包问题

本文由 ImportNew - hejiani 翻译自 javacodegeeks。欢迎加入Java小组。转载请参见文章末尾的要求。

背包问题很有意思,同时也富有挑战性。首先看一下这个问题的完整描述:

问题

假定背包的最大容量为W,N件物品,每件物品都有自己的价值和重量,将物品放入背包中使得背包内物品的总价值最大。

背包问题wiki

可以想象这样一个场景——小偷在屋子里偷东西,他带着一只背包。屋子里物品数量有限——每件物品都具有一定的重量和价值——珠宝重量轻但价值高,桌子重但价值低。最重要的是小偷背包容量有限。很明显,他不能把桌子分成两份或者带走珠宝的3/4。对于一件物品他只能选择带走或者不带走。

示例:

1 Knapsack Max weight : W = 10 (units)
2 Total items         : N = 4
3 Values of items     : v[] = {10, 40, 30, 50}
4 Weight of items     : w[] = {5, 4, 6, 3}

从示例数据大致估算一下,最大重量为10时背包能容纳的物品最大价值为50+40=90,重量为7。

解决方法:

最佳的解决方法是使用动态规划——先得到该问题的局部解然后扩展到全局问题解。

构建物品X在不同重量时的价值数组V(Value数组):

1 V[N][W] = 4 rows * 10 columns

该矩阵中的每个值的求解都代表一个更小的背包问题。

初始情况一:对于第0列,它的含义是背包的容量为0。此时物品的价值呢?没有。因此,第一列都填入0。

初始情况二:对于第0行,它的含义是屋内没有物品。那么没有任何物品的背包里的价值多少呢?还是没有!所有都是0。

步骤:

1、现在,开始填入数组每一行的值。第1行第1列代表什么含义呢?对于第一个物品,可以把重量为1的该物品放入背包吗?不行。第一个物品的重量是5。因此,填入0。实际上直到第5列(重量5)之前都应该填入0。
2、对于第1行的第5列(重量5),意味着将物品1放入背包。填入10(注意,这是Value数组):

3、继续,对于第6列,我们可以再放入重量为1(重量值-物品的重量)的物品吗。我们现在只考虑物品1。由于我们加入物品1之后就不能再加入额外的重量,可以很直观地看到其余的列都应该还是相同的值。

4、接着,有意思的事情就要出现了。在第3行第4列,此时重量为4。

需要作以下判断:

  1. 可以放入物品2吗——可以。物品2的重量为4。
  2. 不加入物品2的话当前已有物品的重量的Value值是否更大——查看相同重量时的前一行的值。不是。前一行的值为0,重量4时不能放入物品1。
  3. 在这个重量时可以放入两件物品使得价值最大吗?——不能。此时重量减去物品2的重量后为0。

为什么是前一行?

简单来说,重量为4的前一行的值本身就是个更小的背包问题解,它的含义是到该重量时背包内物品的最大价值(通过遍历物品得到)。

举个例子:

  1. 当前物品价值 = 40
  2. 当前物品重量 = 4
  3. 剩余重量 = 4-4 = 0
  4. 查看上面的行(物品1或者其余行的值)。剩余容量为0时,可以再容纳物品1吗?对于该给定的重量值上面的行还有任何值吗?

计算过程如下:

1) 计算不放入该物品时该重量的最大价值:

1 previous row, same weight = 0
2
3 => V[item-1][weight]

2) 计算当前物品的价值 + 可以容纳的剩余重量的价值

1 Value of current item
2 + value in previous row with weight 4 (total weight until now (4) - weight of the current item (4))
3
4 => val[item-1] + V[item-1][weight-wt[item-1]]

找到二者之中的最大值40(0和40)。

3) 下一次最重要的位置为第2行第9列。意味着此时重量为9,放入两件物品。根据示例数据现在可以放入两件物品。我们作了以下判断:

1 The value of the current item = 40
2 The weight of the current item = 4
3 The weight that is left over = 9 - 4 = 5
4 Check the row above.  At the remaining weight 5, are we able to accommodate Item 1.

计算如下:

1. 不加入该物品时该重量的最大价值:

1 previous row, same weight = 10

2. 计算当前物品的价值+可以容纳的剩余重量的价值

1 Value of current item (40)
2 + value in previous row with weight 5 (total weight until now (9) - weight of the current item (4))
3
4 = 10

10vs50 = 50。

解决了所有的子问题之后,返回V[N][W]的值——4件物品重量为10时:

复杂度

解法的复杂度非常直观。在N次循环中有W次循环 => O(NW)

实现

Java代码实现:

 1 public class Knapsack {
 2     public static void main(String[] args) throws Exception {
 3         int val[] = {10, 40, 30, 50};
 4         int wt[] = {5, 4, 6, 3};
 5         int W = 10;
 6
 7         System.out.println(knapsack(val, wt, W));
 8     }
 9
10     public static int knapsack(int val[], int wt[], int W) {
11         //Get the total number of items.
12         //Could be wt.length or val.length. Doesn‘t matter
13         int N = wt.length;
14
15         //Create a matrix.
16         //Items are in rows and weight at in columns +1 on each side
17         int[][] V = new int[N + 1][W + 1];
18
19         //What if the knapsack‘s capacity is 0 - Set
20         //all columns at row 0 to be 0
21         for (int col = 0; col <= W; col++) {
22             V[0][col] = 0;
23         }
24
25         //What if there are no items at home.
26         //Fill the first row with 0
27         for (int row = 0; row <= N; row++) {
28             V[row][0] = 0;
29         }
30
31         for (int item=1;item<=N;item++){
32             //Let‘s fill the values row by row
33             for (int weight=1;weight<=W;weight++){
34                 //Is the current items weight less
35                 //than or equal to running weight
36                 if (wt[item-1]<=weight){
37                     //Given a weight, check if the value of the current
38                     //item + value of the item that we could afford
39                     //with the remaining weight is greater than the value
40                     //without the current item itself
41                     V[item][weight]=Math.max (val[item-1]+V[item-1][weight-wt[item-1]], V[item-1][weight]);
42                 }
43                 else {
44                     //If the current item‘s weight is more than the
45                     //running weight, just carry forward the value
46                     //without the current item
47                     V[item][weight]=V[item-1][weight];
48                 }
49             }
50
51         }
52
53         //Printing the matrix
54         for (int[] rows : V) {
55             for (int col : rows) {
56                 System.out.format("%5d", col);
57             }
58             System.out.println();
59         }
60
61         return V[N][W];
62     }
63 }

运行结果:

    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0   10   10   10   10   10   10
    0    0    0    0   40   40   40   40   40   50   50
    0    0    0    0   40   40   40   40   40   50   70
    0    0    0   50   50   50   50   90   90   90   90
90


原文链接: javacodegeeks 翻译: ImportNew.comhejiani
译文链接: http://www.importnew.com/13072.html
转载请保留原文出处、译者和译文链接。]



本文来源:http://www.importnew.com/13072.html

时间: 2024-11-10 08:02:50

【转】经典算法:背包问题的相关文章

数据挖掘十大经典算法

一. C4.5  C4.5算法是机器学习算法中的一种分类决策树算法,其核心算法是ID3 算法.   C4.5算法继承了ID3算法的优点,并在以下几方面对ID3算法进行了改进: 1) 用信息增益率来选择属性,克服了用信息增益选择属性时偏向选择取值多的属性的不足: 2) 在树构造过程中进行剪枝: 3) 能够完成对连续属性的离散化处理: 4) 能够对不完整数据进行处理. C4.5算法有如下优点:产生的分类规则易于理解,准确率较高.其缺点是:在构造树的过程中,需要对数据集进行多次的顺序扫描和排序,因而导

动态展示十大经典算法

算法一:快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序n个项目要Ο(nlogn)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(nlogn)算法更快,因为它的内部循环(innerloop)可以在大部分的架构上很有效率地被实现出来. 快速排序使用分治法(Divideandconquer)策略来把一个串行(list)分为两个子串行(sub-lists). 算法步骤: 1.从数列中挑出一个元素,称为“基准”(pivot),

经典算法宝典——动态规划思想(六)(2)

1.01背包问题 有N件物品和一个容量为V的背包,第i件物品的体积是c[i],价值是w[i].求解将哪些物品装入背包可使价值总和最大. 解析: 这是最基础的背包问题,特点是每种物品仅有一件,可以选择放或不放.用子问题定义状态,即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值.其状态转移方程便是f[i][v] = max{f[i-1][v], f[i-1][v-c[i]]+w[i]},这个方程非常重要,基本上所有跟背包相关的问题的方程都是由它衍生出来的,所以有必要将它详细解

【经典算法大全】收集51种经典算法 初学者必备

<经典算法大全>是一款IOS平台的应用.里面收录了51种常用算法,都是一些基础问题.博主觊觎了好久,可悲哀的是博主没有苹果,所以从网上下了老奔的整理版并且每个都手敲了一遍. 虽然网上也有博客贴了出来,但是自己写写感觉总是好的.现在分享个大家. 代码和运行结果难免有出错的地方,请大家多多包涵. 1.河内之塔(汉诺塔) 2.费式数列 3.巴斯卡三角形 4.三色棋 5.老鼠走迷宫(1) 6.老鼠走迷宫(2) 7.骑士走棋盘 8.八皇后 9.八枚银币 10.生命游戏 11.字串核对 12.双色河内塔,

经典算法大全

原文地址:经典算法大全 作者:liurhyme 经                                                                    典                                                                    算                                                                    法                  

编程算法 - 背包问题(递归) 代码(C)

背包问题(递归) 代码(C) 本文地址: http://blog.csdn.net/caroline_wendy 题目: 有n个重量和价值分别为w,v的物品, 从这些物品中挑选出总重量不超过W的物品, 求所有挑选方案中价值总和的最大值. 即经典动态规划问题. 可以使用深度优先搜索, 把每个部分都遍历到, 选取最优解, 但不是最好的方法. 代码: /* * main.cpp * * Created on: 2014.7.17 * Author: spike */ /*eclipse cdt, gc

程序员必须要掌握的十大经典算法

算法一:快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来. 快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists). 算法步骤: 1 从数列中挑出一个元素,称为 "

数据挖掘领域十大经典算法初探

译者:July   二零一一年一月十五日 ----------------------------------------- 参考文献:国际权威的学术组织ICDM,于06年12月年评选出的数据挖掘领域的十大经典算法:C4.5, k-Means, SVM, Apriori, EM, PageRank, AdaBoost, kNN, Naive Bayes, and CART.==============博主说明:1.原文献非最新文章,只是本人向来对算法比较敏感.感兴趣,便把原文细看了下,翻译过程中

【白话经典算法系列之十七】 数组中只出现一次的数 其他三次

本文地址:http://blog.csdn.net/morewindows/article/details/12684497转载请标明出处,谢谢. 欢迎关注微博:http://weibo.com/MoreWindows 首先看看题目要求: 数组A中,除了某一个数字x之外,其他数字都出现了三次,而x出现了一次.请给出最快的方法找到x. 这个题目非常有意思,在本人博客中有<位操作基础篇之位操作全面总结>这篇文章介绍了使用位操作的异或来解决——数组中其他数字出现二次,而x出现一次,找出x.有<

三白话经典算法系列 Shell排序实现

山是包插入的精髓排序排序.这种方法,也被称为窄增量排序,因为DL.Shell至1959提出命名. 该方法的基本思想是:先将整个待排元素序列切割成若干个子序列(由相隔某个"增量"的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序. 由于直接插入排序在元素基本有序的情况下(接近最好情况),效率是非常高的,因此希尔排序在时间效率上比前两种方法有较大提高. 以n=10的一个数组49, 38, 65, 97