算法分析与设计——蛮力法0/1背包

蛮力法0/1背包

蛮力法

蛮力法是一种简单直接解决问题的方法，常常直接基于问题的描述，所以蛮力法也是最容易应用的方法。

蛮力法所依赖 的基本技术是遍历，即采用一定的策略依次处理待求解问题的所有元素，从而找出问题的解。由于其需要依次穷举待处理的元素，因此蛮力法是一种典型的指数级时间算法。

问题

给定n个重量为{w₁,w₂,···,w_n}、价值为{v₁,v₂,···,v_n}的物品和一个容量为C的背包，0/1背包是一个求解这些物品中的一个最有价值的子集，并且能够装入到背包中。

应用实例

有n项可投资的项目，每个项目需要投入资金s_i，可获利润为v_i，现有可用资金M，应选择那些项目来投资才能获得最大利润。

想法

用蛮力法解决0/1背包问题，需要考虑给定n个物品集合的所有子集，找出所有重量不超过背包容量的子集，计算每个可能子集的总价值，然后找到价值最大的子集。例如，给定4个物品的重量为{7,3,4,5}，价值为{42,12,40,25}，和一个容量为10的背包，下表为求解的过程。

序号	子集	总重量	总价值
1	∅	0	0
2	{1}	7	42
3	{2}	3	12
4	{3}	4	40
5	{4}	5	25
6	{1,2}	10	54
7	{1,3}	11	不可行
8	{1,4}	12	不可行
9	{2,3}	7	52
10	{2,4}	8	37
11	{3,4}	9	65
12	{1,2,3}	14	不可行
13	{1,2,4}	15	不可行
14	{1,3,4}	16	不可行
15	{2,3,4}	12	不可行
16	{1,2,3,4}	19	不可行

伪代码

输入：重量{w₁,w₂,···,w_n}，价值{v₁,v₂,···,v_n}，容量C
输出：装入背包的物品编号

1. 初始化最大价值maxValue=0；结果子集S=∅；
2. 对集合{1,2,···,n}的每一个子集T，执行如下操作：
   2.1 初始化背包的价值value=0；背包的重量weight=0；
   2.2 对子集T的每一个元素j
   2.2.1 如果weight+w_j＜C，则weight=weight+w_j；value=value+v_j；
   2.2.2 否则，转入步骤2考察下一个子集；
   2.3 如果maxValue＜value，则maxValue=value；S=T；
3. 输出S中的各元素；

源代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
//用于计算程序运算时间
#include<ctime>

using namespace std;

#define N 100

struct goods{
int sign;//物品序号
int wight;//物品重量
int value;//物品价值
};

int n, maxValue, cv, cw, C;//物品数量，价值最大，当前价值，当前重量，背包容量
int X[N],cx[N];//最终存储状态，当前存储状态
struct goods goods[N];

int Force(int i)
{
    if(i > n-1)
    {
        if(maxValue < cv && cw + goods[i].wight <= C)
        {
            for(int k = 0;k < n;k++)
                X[k] = cx[k];//存储最优路径
            maxValue = cv;
        }

        return maxValue;
    }

    cw = cw + goods[i].wight;
    cv = cv + goods[i].value;
    cx[i] = 1;//装入背包

    Force(i+1);
    cw = cw-goods[i].wight;
    cv = cv-goods[i].value;
    cx[i] = 0;//不装入背包

    Force(i+1);

    return maxValue;
}

int main()
{
    clock_t starttime,finish; //用于计算时间
    double time;
    starttime=clock();//用于计算程序运行时间

    printf("物品种类n：");
    scanf("%d",&n);
    printf("背包容量C：");
    scanf("%d",&C);

    for(int i = 0; i < n; i++)
    {
        printf("物品%d的重量w[%d]及其价值v[%d]：",i+1,i+1,i+1);
        scanf("%d%d",&goods[i].wight,&goods[i].value);
    }

    int sum1 = Force(0);

    printf("蛮力法求解0/1背包问题：\nX=[");

    for(int i = 0; i < n; i++)
    {
        cout << X[i]<<" ";
    }

    printf("] 装入总价值%d\n",sum1);

    finish=clock();
    time = (double)(finish-starttime)/1000;//时间单位为秒
    starttime=clock();//用于计算程序运行时间

    cout<<"time is:"<<time<<endl;

    return 0;
}

算法分析

对于一个具有n个元素的集合，其子集数量是2ⁿ，所以无论生成子集的算法效率有多高，蛮力法求解0/1背包都会是一个Ω(2ⁿ)的算法。