用动态规划算法解决0-1背包问题

用动态规划算法解决0-1背包问题需要了解以下基本概念和原理：
1.使用动态规划算法必须具备两个基本要素：最优子结构性质和重叠子问题性质
2.动态规划算法常以自底向上的方式计算最优值，也就是说，从最小的子问题开始向包含该子问题的大问题方向求解，把每一次求解出的子问题的解保存下来，以便提供给包含该小问题的大问题使用，因此使用循环迭代方式计算更为合理，但从动态规划算法的两个基本要素可以看出，直接以递归方式计算更为简便，于是乎，就产生了动态规划算法的变形方法：备忘录算法。备忘录算法在递归调用过程中将已经求出的子问题的解保存下来，以便下次递归调用遇到相同的子问题可直接获取该子问题的解。
3.动态规划算法在求解最优值的过程中，将遇到的所有子问题的解记录在一张表中，同时也将一些能构造最优解的必要信息记录下来，以便用这些信息构造最优解。求解最优值的过程也俗称“填表过程”。
4.设计动态规划算法的通常的步骤：
（1）找出最优解的性质，并刻画其结构特征
（2）递归地定义最优值
（3）以自底向上的方式计算最优值
（4）根据计算最优值时得到的信息构造最优解
5.0-1背包问题具有最优子结构性质和重叠子问题性质。
定义m(i,j):从物品i、i+1、...、n-1、n中选择物品装入容量大小为j的背包，使该背包的总价
值最大，最大值为m(i,j),也即最优值。
假设背包容量为c，物品总数n,物品i的重量表示wi,价值表示vi，于是0-1背包问题的最优值为
m(1,c)。计算m(1,c)的值之前，先递归地定义最优值的计算方法：
（1）当背包剩余容量为j时，且j >= wi, m(i,j) = max{ m(i+1,j), m(i+1,j-wi)+vi)};说明
此时的背包剩余容量大于物品i的重量，于是在选取物品i和舍弃物品i之中选择较大的。
（2）当背包剩余容量为j时，且0< j < wi, m(i,j) = m(i+1,j); 说明物品i的重量大于背包此时
剩余容量，于是，对物品i舍弃。
（3）最小的子问题，也即只有一个物品时，如何装入背包使背包的总价值最大。假设背包剩余
容量为j时，同时只有一个物品n供选择时，此时，若j > wn, 则最大价值为wn，即 m(n,j) =
wn；若j < wn, 则最大价值为0,即 m(n,j) = 0。

注：上述考虑的物品重量和背包容量都为整数。因此，使用二维数组m[i][j]表示m(i,j)

以下是源代码：

#include "stdafx.h";
#include <iostream>;
using namespace std;

#define C  10
#define N  5

void Knapsack(int *w, int *v, int n, int c, int (*m)[C+1])
{
    //先处理记录表格中的最后一行，也即完成对m[n][j]的“填空”
    int lowc = w[n]-1 > c ? c : w[n]-1;
    for (int j = 0; j <= lowc; j++)
        m[n][j] = 0;
    for (int j = lowc+1; j <= c; j++)
        m[n][j] = v[n];
    //循环处理记录表格中的其他行，也即完成对m[i][j]的“填空”
    for (int i = n-1; i > 1; i--)
    {
        lowc = w[i]-1 > c ? c : w[i]-1;
        for (int j = 0; j <=lowc; j++)
            m[i][j] = m[i+1][j];
        for (int j = lowc+1; j <=c; j++)
        {
            int t1 = m[i+1][j];
            int t2 = m[i+1][j - w[i]] + v[i];
            m[i][j] = t1 > t2 ? t1 : t2;
        }
    }
    //处理记录表格中的第一行，也即完成对m[1][c]的“填空”
    m[1][c] = m[2][c]; //背包容量c不足,物品1舍去
    if(c >= w[1] && m[2][c-w[1]] + v[1] > m[2][c]) //背包容量c足够,并且选取物品1的情况价值较大
        m[1][c] = m[2][c-w[1]] +v[1];
}

void Traceback(int (*m)[C+1],int *w, int *x,int n, int c)
{
    for (int i = 1; i < n; i++)
    {
        if(m[i][c] == m[i+1][c])
            x[i] = 0;
        else
        {
            x[i] = 1;
            c -= w[i];
        }
    }
    w[n] < c ? x[n] =1 : x[n] =0;
}

int _tmain()
{
    int x[N+1];
    int w[N+1] ={-1,2,2,6,5,4};
    int v[N+1] ={-1,6,3,5,4,6};
    int m[N+1][C+1];
    Knapsack(w,v,N,C,m);
    cout<<m[1][C]<<endl;
    Traceback(m, w, x, N, C);
    for (int i = 1; i <= N; i++)
    {
        cout<<x[i]<<" ";
    }
    cout<<endl;
    system("pause");
    return 0;
}

运行结果如下：

15

1 1 0 0 1

从上述算法分析中，有两个较明显的缺点。其一是算法要求所给物品的重量wi是整数。其次，背包容量c很大时，算法所需要的计算时间和空间较多。因此，对上述算法提出改进，使物品重量和背包容量允许为实数（大于0的实数），同时减少所需的时间和空间复杂度。改进分析：
1.将二维表m(i,j)看成函数，对于确定的i，函数m(i,j)是关于变量j的阶梯状单调不减函数。通过跳跃点描述阶梯状的函数m(i,j)。比如，物品n重量大小5,价值为8那么，
当j>=5时，m(n,j) = 8 ;当0<= j < 5时, m(n,j) = 0;可以看出背包容量大小5是m(n,j)的分界容量，所以，(0,0)和(5,8)是函数m(n,j)的两个跳跃点。因此，只需对函数m(i,j)所有的跳跃点保存，无需建立二维表m，从而节省内存空间。最后的最优值从函数m(1,j)的所有跳跃点中获得。
2.每个跳跃点对应一个数组，记录以往选取物品的编号。最优解的构造从函数m(1,j)中的第一个不超过背包容量c对应的跳跃点中获得。（注意，对于确定的i，函数m(i,j)所有的跳跃点按j递增排序。）
3.用p[i+1]表示函数m(i+1,j)的跳跃点集，q[i+1]表示p[i+1]包含物品i之后的跳跃点集，则p[i]等于p[i+1]与q[i+1]的合并（并不是单纯合并，因为有些跳跃点受控于其他的跳跃点）。
举例说明：
背包容量c：5
物品数量n：3
物品重量数组w：2，3，5
物品价值数组v：6，4，8
初始化p[4]的跳跃点集：（0，0）
若加入物品3之后，出现的跳跃点：（5，8），所以合并之后，
p[3]的跳跃点集：（0，0），（5，8）
若加入物品2之后，出现的跳跃点：（3，4），（8，12），所以合并之后，
p[2]的跳跃点集：（0，0），（3，4），（5，8），（8，12）
若加入物品1之后，出现的跳跃点：（2，6），（5，10），（7，14），（10，18），所以合并之后，
p[1]的跳跃点集：（0，0），（2，6），（5，10），（7，14），（10，18）
最终的最优值从p[1]的跳跃点集中寻找，比如:
（1）若背包容量5，对应的跳跃点为（5，10），因此，背包装载物品的最大价值为10.
（2）若背包容量8，对应的跳跃点为（7，14），因此，背包装载物品的最大价值为14.

以下是改进算法：

#include "stdafx.h"
#include <iostream>
using namespace std;

//物品类
class Object
{
    friend class Knapsack;
    int number;
    double weight;
    double value;
};

//跳跃点类
class JumpNode
{
    friend class Knapsack;
    friend void Print();
    double enoughw; //排序的依据
    double enoughv;
    int amount;
    int *selected;
    JumpNode *next;
    
};

//0-1背包问题主类
class Knapsack
{
    Knapsack(int n, double *w, double *v, double c);
    friend void Print();
public:
    void DynamicProgram();
private:
    int n;
    double c;
    Object *Ot;
    JumpNode *firstp;
    JumpNode *firstq;
    JumpNode *abandon;
};

//动态规划解决0-1背包问题（物品重量允许大于零的实数）
void Knapsack::DynamicProgram()
{
    int i = n;
    for (; i >= 1; i--)
    {
        //对firstp中的结点用物品i进行“升级”，保存在firstq中
        JumpNode *jptr = firstp;
        JumpNode *lastq = firstq;
        bool isfq = true;
        while (jptr != nullptr)
        {    
            if(jptr->enoughw + Ot[i].weight <= c)
            {
                JumpNode *temp;
                if(abandon != nullptr)
                {
                    temp = abandon;
                    abandon = temp->next;
                }    
                else
                {
                    temp = new JumpNode;
                    temp->selected = new int[n+1];
                }
                temp->amount = jptr->amount + 1;
                temp->enoughw = jptr->enoughw + Ot[i].weight;
                temp->enoughv = jptr->enoughv + Ot[i].value;
                for (int j = 1; j < temp->amount ; j++)
                    temp->selected[j] = jptr->selected[j];
                temp->selected[temp->amount] = Ot[i].number;
                temp->next = nullptr;
                //把temp结点插入到firstq中
                if(isfq)
                {
                    firstq = temp;
                    lastq = temp;
                    isfq = false;
                }
                else
                {
                    lastq->next = temp;
                    lastq = temp;
                }
            }
            jptr = jptr->next;            
        }
        if(!isfq)
            lastq->next = nullptr;

        //对firstp和firstq合并，最后放到firstp
        if(firstq != nullptr)
        {
            JumpNode *firsttemp = nullptr;
            JumpNode *temp = nullptr;
            bool isfirst = true;
            double cmaxvalue = 0;
            while ((firstp != nullptr) && (firstq != nullptr))
            {
                if(firstp->enoughw < firstq->enoughw)
                {
                    if(isfirst)
                    {
                        temp = firstp;
                        firstp = firstp->next;
                        firsttemp = temp;
                        isfirst = false;
                        cmaxvalue = temp->enoughv;
                    }
                    else
                    {
                        temp->next = firstp;
                        temp = firstp;
                        firstp = firstp->next;
                        cmaxvalue = temp->enoughv;
                    }
                }
                else
                {
                    if(firstp->enoughw == firstq->enoughw)
                    {
                        if(firstp->enoughv > firstq->enoughv)
                        {
                                temp->next = firstp;
                                temp = firstp;
                                firstp = firstp->next;
                                cmaxvalue = temp->enoughv;
                                JumpNode *ab;
                                ab = firstq->next;
                                if(abandon != nullptr) //回收
                                {
                                    firstq->next = abandon->next;
                                    abandon->next = firstq;
                                }
                                else
                                    abandon = firstq;
                                firstq = ab;

                        }
                        else
                        {
                                temp->next = firstq;
                                temp = firstq;
                                firstq = firstq->next;
                                cmaxvalue = temp->enoughv;
                                JumpNode *ab;
                                ab = firstp->next;
                                if(abandon != nullptr) //回收
                                {
                                    firstp->next = abandon->next;
                                    abandon->next = firstp;
                                }
                                else
                                    abandon = firstp;
                                firstp = ab;
                        }
                    }
                    else //firstp->enoughw > firstq->enoughw
                    {
                        if(firstq->enoughv > cmaxvalue)
                        {
                            temp->next = firstq;
                            temp = firstq;
                            firstq = firstq->next;
                            cmaxvalue = temp->enoughv;
                        }
                        else
                        {
                            JumpNode *ab;
                            ab = firstq->next;
                            if(abandon != nullptr) //回收
                            {
                                firstq->next = abandon->next;
                                abandon->next = firstq;
                            }
                            else
                                abandon = firstq;
                            firstq = ab;                    
                        }
                    }
                }
                        
            }//while
            if(firstq == nullptr)
                while (firstp != nullptr)
                {
                    if(firstp->enoughv <= cmaxvalue) //回收
                    {
                        JumpNode *ab;
                        ab = firstp->next;
                        if(abandon != nullptr) //回收
                        {
                            firstp->next = abandon->next;
                            abandon->next = firstp;
                        }
                        else
                            abandon = firstp;
                        firstp = ab;    
                    }
                    else
                    {
                        temp->next = firstp;
                        temp = firstp;
                        firstp = firstp->next;
                        cmaxvalue = temp->enoughv;
                    }
                }
            else
            {
                while (firstq != nullptr)
                {
                    if(firstq->enoughv <= cmaxvalue) //回收
                    {
                        JumpNode *ab;
                        ab = firstq->next;
                        if(abandon != nullptr) //回收
                        {
                            firstq->next = abandon->next;
                            abandon->next = firstq;
                        }
                        else
                            abandon = firstq;
                        firstq = ab;    
                    }
                    else
                    {
                        temp->next = firstq;
                        temp = firstq;
                        firstq = firstq->next;
                        cmaxvalue = temp->enoughv;
                    }
                }
            }
            temp->next = nullptr;
            firstp = firsttemp;
        }        
    }//for
}

Knapsack::Knapsack(int n, double *w, double *v, double c):n(n),c(c)
{
    Ot = new Object[n+1];
    for (int i = 1; i <=n; i++)
    {
        Ot[i].number = i;
        Ot[i].weight = w[i-1];
        Ot[i].value = v[i-1];
    }
    //创建跳跃点(0,0)
    JumpNode *newNode = new JumpNode;
    newNode->amount = 0;
    newNode->enoughv =0;
    newNode->enoughw =0;
    newNode->next =nullptr;
    newNode->selected = new int[n+1];
    firstp = newNode;
    firstq = nullptr;
}

void Print()
{
    const int N = 4; //物品数量
    int c = 7; //背包容量
    double w[N] = {2,3,5,2}; //物品重量数组
    double v[N] = {6.6,4.6,8.5,4.6}; //物品价值数组
    Knapsack *K = new Knapsack(N, w, v, c);
    K->DynamicProgram();
    JumpNode *scan = K->firstp;
    int *selarr;
    int count = 0;
    double selvalue = 0;
    JumpNode *oldscan = scan;
    while (scan != nullptr)
    {
        if(scan->enoughw > c)
            break;
        oldscan = scan;
        scan = scan->next;
    }
    selarr = oldscan->selected;
    selvalue = oldscan->enoughv;
    count = oldscan->amount;
    if(count > 0)
        cout<<"已选的物品编号如下："<<endl; //物品编号从1开始
    for (int i = count; i >0; i--)
        cout<<selarr[i]<<" ";
    if(count == 0)
        cout<<"背包容量不足，任何物品都不能装入背包"<<endl;
    else
        cout<<endl<<"背包装载的物品最大价值："<<selvalue<<endl;
    system("pause");
}

int _tmain()
{
    Print();
    return 0;
}

运行结果如下：

已选的物品编号如下：

1 2 4

背包装载的物品最大价值：15.8