0-1背包问题的迭代回溯算法实现（C++）

编译环境：Dev-C++

迭代回溯方法求解0-1背包问题的具体算法实现

---

0-1背包问题描述：

        我们有n种物品，物品j的重量为wj，价格为pj。我们假定所有物品的重量和价格都是非负的。背包所能承受的最大重量为c。如果限定每种物品只能选择0个或1个，则问题称为0-1背包问题。计算出背包能承受的最大价值量。

0-1背包问题形式化描述：

给定c＞0，wi＞0，vi＞0，1≤i≤n，求n元0-1向量(x1, x2, …, xn)，使得

在本次试验中，使用到的实例为：n=7，c=150，w={35,30,60,50,40,10,25}，p={10,40,30,50,35,40,30}.  

---

 算法设计实现描述：

        回溯法在包含问题的所有解的解空间树中按照深度优先的策略，确定了解空间的组织结构后，回溯法从开始节点出发，以深度优先方式搜索整个解空间，这个开始节点成为活节点，同时成为当前的扩展结点。

        在当前的可扩展结点处，搜索向纵深方向移至一个新的结点，这个新结点成为当前的活结点，并成为扩展结点。如果在当前的可扩展结点处不能向纵深方向移动（结点不包含问题解，或者到达叶子结点），则当前扩展结点变成死结点。此时，应回溯至最近的一个活动结点处，并使这个活动结点成为当前的扩展结点。回溯法以这种工作方式递归地在解空间中搜索，直至找到所要求的解或者解空间中已无活动结点为止。

不妨设  bestw :当前最优载重量；

          cw   :当前扩展结点Z的载重量 ;

           r    :当前扩展结点Z的剩余集装箱重量;

回溯法解题步骤：

1、针对所给问题，定义问题的解空间；

2、确定易于搜索的解空间结构；

3、以深度优先搜索的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索

剪枝函数：

1、搜索左子树时：用约束函数在扩展结点处剪去不满足约束的左子树（约束函数cw+wi >C时，剪掉左子树）

2、搜索右子树时：用限界函数剪去得不到最优解的右子树（限(上)界函数cp+r<Bestv时, 剪掉右子树）

---

调试过程及结果

程序执行的结果:

0-1背包问题回溯算法的复杂性分析：

在本算法中，计算上界需要O(n)时间，在最坏情况下有O(2­n) 个右儿子结点需要计算上界。所以，解0-1背包问题的回溯算法Backtrack所需要的计算时间为O(n2­n)。

---

 源代码：

#include<bits/stdc++.h>
using namespace std;
class Knap{
    friend int Knapsack(int*,int*,int,int,Knap&);
public:
    int c;      //背包容量
    int n;      //物品个数
    int* w;     //重量信息
    int* p;     //价值信息
    int cw;     //当前重量
    int cp;     //当前价值
    int bestp;  //当前最优价值
    int *x,     //当前解
        *bestx; //当前最优解
    int Bound(int i);            //限界函数
    void Iterative_Backtrack();  //迭代深度优先遍历
};
int Knap::Bound(int i){          //求解第i层的限界函数（按照背包问题的贪心策略）
    int cleft = c - cw;
    int b = cp;
    while(i<=n&&w[i]<=cleft){
        b += p[i];
        cleft -= w[i];
        i++;
    }
    if(i<=n) b += cleft*(p[i]/w[i]);
    return b;
}
void Knap::Iterative_Backtrack(){
    int t = 1;
    while(t>0){                      //t<=0时表示已经遍历完成，结束循环
        while(t<=n && cw+w[t]<=c){   //如果能装下去就继续装，即深度访问其左儿子
            x[t] = 1;
            cw += w[t];
            cp += p[t];
            t++;
        }
        if(t > n){                  //如果到达叶子节点，更新最优值和最优解，并输出当前最优解
            for(int i=1;i<=n;i++){
                bestx[i] = x[i];
               }
            bestp = cp;
            for(int i=1;i<=n;i++){
                cout<<x[i]<<" ";
            }
            cout<<" value "<<cp<<endl;
}
        else{                     //如果没有到达叶子节点，则访问其右儿子
            x[t] = 0;
            t++;
        }
        while(Bound(t+1) <= bestp){  //如果右儿子不满足限界条件则需回溯
           t--;
           while(t>=1 && !x[t]){     //回溯到右儿子没有被访问过的节点
                t--;
            }
            if(t<=0)
                break;
           x[t] = 0;                //访问最终回溯节点的右儿子
           cw -= w[t];              //更新相应值
           cp -= p[t];
                                    //再次进入循环判断右儿子是否符合限界函数
          }
}
}
class Object{                                        //物品类
    friend int Knapsack(int*,int*,int,int,Knap&);
    friend bool cmp(Object,Object);
private:
    int id;
    double aver;
};
bool cmp(Object a,Object b){
    return a.aver>b.aver;
}
int Knapsack(int* w,int* p,int c,int n,Knap& K){   //初始化以及调用重要的函数，因为要访问类内私有成员所以声明为友元函数
    int W = 0;
    int P = 0;
    Object* Q = new Object[n];
    for(int i=1;i<=n;i++){
        Q[i-1].id = i;
        Q[i-1].aver = 1.0*p[i]/w[i];
        P += p[i];
        W += w[i];
}
    if(W<c) return P;
    sort(Q,Q+n,cmp);                      //依照单位重量的价值进行排序
    K.p = new int[n+1];
    K.w = new int[n+1];
    K.x = new int[n+1];
    K.bestx = new int[n+1];
    for(int i=1;i<=n;i++){                //依照物品的单位重量的价值进行初始化
        K.p[i] = p[Q[i-1].id];
        K.w[i] = w[Q[i-1].id];

    }
    K.cp = 0; K.cw = 0; K.c = c; K.n = n; K.bestp = 0;
    K.Iterative_Backtrack();             //调用重要遍历函数
    delete [] Q; delete [] K.w; delete [] K.p;delete [] K.x;
             return K.bestp;

}
void Init(int* &w,int* &p,int& c,int& n){        //输入背包的相关信息
    cout<<"input number of object and capacity of bag"<<endl;
    cin>>n>>c;
    w = new int[n+1];
    p = new int[n+1];
    cout<<"input weight of objects"<<endl;
    for(int i=1;i<=n;i++){
        cin>>w[i];
    }
    cout<<"input value of objects"<<endl;
    for(int i=1;i<=n;i++){
        cin>>p[i];
    }
}
void Print(int bestp,int n,int*& x){
    cout<<"max value is"<<endl;
    cout<<bestp<<endl;
    cout<<"The optimal solution is"<<endl;
    for(int i=1;i<=n;i++){
       cout<<x[i]<<" ";
    }
}
int main(){
    int *w=NULL,*p=NULL;
    int c,n;
    Knap K;
    Init(w,p,c,n);
    Print(Knapsack(w,p,c,n,K),n,K.bestx);
    return 0;
}