动态规划之01背包问题

01背包问题，是用来介绍动态规划算法最经典的例子，网上关于01背包问题的讲解也很多，我写这篇文章力争做到用最简单的方式，最少的公式把01背包问题讲解透彻。

01背包的状态转换方程 f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ),  f[i-1,j] }

f[i,j]表示在前i件物品中选择若干件放在承重为 j 的背包中，可以取得的最大价值。

Pi表示第i件物品的价值。

决策：为了背包中物品总价值最大化，第 i件物品应该放入背包中吗 ？

题目描述：

有编号分别为a,b,c,d,e的五件物品，它们的重量分别是2,2,6,5,4，它们的价值分别是6,3,5,4,6，现在给你个承重为10的背包，如何让背包里装入的物品具有最大的价值总和？

name	weight	value	1	2	3	4	5	6	7	8	9	10
a	2	6	0	6	6	9	9	12	12	15	15	15
b	2	3	0	3	3	6	6	9	9	9	10	11
c	6	5	0	0	0	6	6	6	6	6	10	11
d	5	4	0	0	0	6	6	6	6	6	10	10
e	4	6	0	0	0	6	6	6	6	6	6	6

只要你能通过找规律手工填写出上面这张表就算理解了01背包的动态规划算法。

首先要明确这张表是至底向上，从左到右生成的。

为了叙述方便，用e2单元格表示e行2列的单元格，这个单元格的意义是用来表示只有物品e时，有个承重为2的背包，那么这个背包的最大价值是0，因为e物品的重量是4，背包装不了。

对于d2单元格，表示只有物品e，d时,承重为2的背包,所能装入的最大价值，仍然是0，因为物品e,d都不是这个背包能装的。

同理，c2=0，b2=3,a2=6。

对于承重为8的背包，a8=15,是怎么得出的呢？

根据01背包的状态转换方程，需要考察两个值，

一个是f[i-1,j],对于这个例子来说就是b8的值9，另一个是f[i-1,j-Wi]+Pi；

在这里，

 f[i-1,j]表示我有一个承重为8的背包，当只有物品b,c,d,e四件可选时，这个背包能装入的最大价值

f[i-1,j-Wi]表示我有一个承重为6的背包（等于当前背包承重减去物品a的重量），当只有物品b,c,d,e四件可选时，这个背包能装入的最大价值

f[i-1,j-Wi]就是指单元格b6,值为9，Pi指的是a物品的价值，即6

由于f[i-1,j-Wi]+Pi = 9 + 6 = 15 大于f[i-1,j] = 9，所以物品a应该放入承重为8的背包

以下是actionscript3 的代码

ublic function get01PackageAnswer(bagItems:Array,bagSize:int):Array  
{  
    var bagMatrix:Array=[];  
    var i:int;  
    var item:PackageItem;  
    for(i=0;i<bagItems.length;i++)  
    {  
        bagMatrix[i] = [0];  
    }  
    for(i=1;i<=bagSize;i++)  
    {  
        for(var j:int=0;j<bagItems.length;j++)  
        {  
            item = bagItems[j] as PackageItem;  
            if(item.weight > i)  
            {  
                //i背包转不下item  
                if(j==0)  
                {  
                    bagMatrix[j][i] = 0;  
                }  
                else  
                {  
                    bagMatrix[j][i]=bagMatrix[j-1][i];  
                }  
            }  
            else  
            {  
                //将item装入背包后的价值总和  
                var itemInBag:int;  
                if(j==0)  
                {  
                    bagMatrix[j][i] = item.value;  
                    continue;  
                }  
                else  
                {  
                    itemInBag = bagMatrix[j-1][i-item.weight]+item.value;  
                }  
                bagMatrix[j][i] = (bagMatrix[j-1][i] > itemInBag ? bagMatrix[j-1][i] : itemInBag)  
            }  
        }  
    }  
    //find answer  
    var answers:Array=[];  
    var curSize:int = bagSize;  
    for(i=bagItems.length-1;i>=0;i--)  
    {  
        item = bagItems[i] as PackageItem;  
        if(curSize==0)  
        {  
            break;  
        }  
        if(i==0 && curSize > 0)  
        {  
            answers.push(item.name);  
            break;  
        }  
        if(bagMatrix[i][curSize]-bagMatrix[i-1][curSize-item.weight]==item.value)  
        {  
            answers.push(item.name);  
            curSize -= item.weight;  
        }  
    }  
    return answers;  
}  

动态规划的用法——01背包问题

 

问题主题：著名的01背包问题

问题描述： 有n个重量和价值分别为wi、vi的物品，现在要从这些物品中选出总重量不超过W的物品，求所有挑选方案中的价值最大值。 限制条件： 1<=N<=100 1<=wi 、vi<=100 1<=wi<=10000

样例： 输入 N=4 W[N] = {2, 1, 3, 2} V[N] = {3, 2, 4, 2} 输出 W = 5(选择0，1，3号)

 

 

【解法一】

解题分析：

    用普通的递归方法，对每个物品是否放入背包进行搜索

程序实现:

C++

#include <stdio.h>  
#include <tchar.h>  
#include <queue>  
#include "iostream"  
   
using namespace std;  
   
const int N = 4;  
const int W = 5;  
int weight[N] = {2, 1, 3, 2};  
int value[N] = {3, 2, 4, 2};  
int solve(int i, int residue)   
{  
int result = 0;  
if(i >= N)  
return result;  
if(weight[i] > residue)  
result = solve(i+1, residue);  
else   
{  
result = max(solve(i+1, residue), solve(i+1, residue-weight[i]) + value[i]);  
}  
   
}  
   
int main() {  
int result = solve(0, W);  
cout << result << endl;  
return 0;  
}  

【解法二】

解题分析：

    用记录结果再利用的动态规划的方法，上面用递归的方法有很多重复的计算，效率不高。我们可以记录每一次的计算结果，下次要用时再直接去取，以提高效率

程序实现:

C++

#include <stdio.h>  
#include <tchar.h>  
#include <queue>  
#include "iostream"  
  
using namespace std;  
  
const int N = 4;  
const int W = 5;  
int weight[N] = {2, 1, 3, 2};  
int value[N] = {3, 2, 4, 2};  
int record[N][W];  
void init()  
{  
    for(int i = 0; i < N; i ++)  
    {  
        for(int j = 0; j < W; j ++)   
        {  
            record[i][j] = -1;  
        }  
    }  
}  
  
int solve(int i, int residue)   
{  
    if(-1 != record[i][residue])  
        return record[i][residue];  
    int result = 0;  
    if(i >= N)  
        return result;  
    if(weight[i] > residue)  
    {  
        record[i + 1][residue] = solve(i+1, residue);  
          
    }  
    else   
    {  
        result = max(solve(i+1, residue), solve(i+1, residue-weight[i]) + value[i]);  
    }  
    return record[i + 1][residue] = result;  
}  
  
int main() {  
    init();  
    int result = solve(0, W);  
    cout << result << endl;  
    return 0;  
}  

Java

package greed;  
  
/** 
 * User: luoweifu 
 * Date: 14-1-21 
 * Time: 下午5:13 
 */  
public class Knapsack {  
    private int maxWeight;  
    private int[][] record;  
    private Stuff[] stuffs;  
  
    public Knapsack(Stuff[] stuffs, int maxWeight) {  
        this.stuffs = stuffs;  
        this.maxWeight = maxWeight;  
        int n = stuffs.length + 1;  
        int m = maxWeight+1;  
        record = new int[n][m];  
        for(int i = 0; i < n; i ++) {  
            for(int j = 0; j < m; j ++) {  
                record[i][j] = -1;  
            }  
        }  
    }  
    public int solve(int i, int residue) {  
        if(record[i][residue] > 0) {  
            return record[i][residue];  
        }  
        int result;  
        if(i >= stuffs.length) {  
            return 0;  
        }  
        if(stuffs[i].getWeight() > residue) {  
            result = solve(i + 1, residue);  
        } else {  
            result = Math.max(solve(i + 1, residue),  
                 solve(i + 1, residue - stuffs[i].getWeight()) + stuffs[i].getValue());  
        }  
        record[i][residue] = result;  
        return result;  
    }  
  
    public static void main(String args[]) {  
        Stuff stuffs[] = {  
            new Stuff(2, 3),  
            new Stuff(1, 2),  
            new Stuff(3, 4),  
            new Stuff(2, 2)  
        };  
        Knapsack knapsack = new Knapsack(stuffs, 5);  
        int result = knapsack.solve(0, 5);  
        System.out.println(result);  
    }  
}  
  
class Stuff{  
    private int weight;  
    private int value;  
  
    public Stuff(int weight, int value) {  
        this.weight = weight;  
        this.value = value;  
    }  
  
    int getWeight() {  
        return weight;  
    }  
  
    void setWeight(int weight) {  
        this.weight = weight;  
    }  
  
    int getValue() {  
        return value;  
    }  
  
    void setValue(int value) {  
        this.value = value;  
    }  
}