回溯法----0-1背包问题

[算法描述]

0-1背包问题是子集选取问题。一般情况下,0-1背包问题是NP完全问题。0-1背包问题的解空间可以用子集树表示。解0-1背包问题的回溯法与解装载问题的回溯法十分相似。在搜索解空间树时,只要其左儿子节点是一个可行的节点,搜索就进入其左子树;而当右子树中有可能包含最优解时才进入右子树搜索否则将右子树剪去。设r是当前剩余物品价值总和;cp是当前价值;bestp是当前最优价值。当cp+r<=bestp时,可剪去右子树。计算右子树中解的上界的更好的办法是,将剩余物品依其单位重量价值排序,然后依次装入物品,直至装不下时,再装入该物品的一部分而装满背包,由此得到的价值是右子树的上界

0--1背包的一个实例n=5, c=10, w={2, 2, 6, 5, 4}, v(p)={6, 3, 5, 4, 6}的0-1背包问题的最优解和最优值。<w为重量,v为价值量,n为物品个数,c为背包容量>

[回溯法基本思想]

确定了解空间的组织结构后,【回溯法从开始节点(根节点)出发,以深度优先搜索整个解空间。这个开始的节点为活节点,同时成为当前的扩展节点。在当前的扩展节点处,搜素向纵深方向移至一个新节点。这个新节点就成为新的活节点,并成为当前扩展节点。如果当前节点处不能再向纵深方向移动,则当前扩展节点为死节点。此时,应往回移动到最近的一个活节点处。回溯法以这种方式递归的在解空间中搜素,直至找到所有符合要求的解或解空间中已无活节点。】(即深度优先搜素)

【优化方法】

剪枝(一):当前决策放入的物品总重量已经大于背包容量时,没有必要继续决策,此时可以将其左子树剪掉。

剪枝(二):如果将当前扩展节点后剩下的所有物品都装入还没有目前已求得的最优值大的话,就不在进行决策了,直接返回。

递归回溯时,在当前扩展节点处会通过设置约束函数限界函数。不满足条件的,剪去相应的子树

【0-1背包算法分析】

对于0-1背包问题,可用一颗完全二叉树表示其解空间,针对上述实例(n=5),解空间树有32个可能的解,解空间树如下图所示。

 经剪枝(二)(红框框)先按照单位价值对物品进行从达到下排序。然后按照背包问题计算当前节点的上界仅当进入右子树时才计算,以判断是否可将右子树剪去进入左子树时不需要计算上界,因为其上界与其父节点相同

当前节点的上界 详细计算如下图所示:

这点理解很重要(区别于动态规划)

【0-1背包代码描述】

template<class Typew,class Typep>
class Knap{
    friend Typep Knapsack(Typep*,Typew*,Typew,int);
    private:
      Typep Bound(int i);
      void Backtrace(int i);
      Typew c;// 背包容量
      int n;// 物品数
      Typew *W;// 物品重量数数组
      Typep *p;// 物品价值数组
      Typew cw;// 当前重量
      Typep cp;// 当前价值
      Typep bestp;// 当前最优值
};

template<class Typew,class Typep>
void Knap<Typew,Typep>::Backtrace(int i){
    if(i > n){ //到达叶子结点
        bestp=cp;
        return;
    }
    if(cw + w[i] <= c){ // 进入左子树
        cw += w[i];
        cp += p[i];
        Backtrace(i+1);
        cw -= w[i];
        cp -= p[i];
    }
    if(Bound(i+1) > bestp) // 进入右子树
        Backtrace(i+1);
}

template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i){ // 计算上界
    Typew cleft = c - cw; // 剩余容量
    Typep b = cp;
    while(i <= n&&w[i] <= cleft){ // 以物品单位重量价值递减装入物品
        cleft -= w[i];
        b += p[i];
        i++;
    }
    if(i <= n) // 装满背包
        b += p[i]*cleft/w[i];
    return b;
}

class Object
{
    friend int Knapsack(int *,int *,int ,int);
    public:
        int operator<=(Object a) const{ return(d >= a.d); }
    private:
        int ID;
        float d;
};

template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[],Typew c,int n){ // 为Knap::Backtrace初始化
    Typew W = 0;
    Typep P = 0;
    Object *Q = new Object[n];
    for(int i=1;i<=n;i++){
        Q[i-1].ID = i;
        Q[i-1].d = 1.0*p[i]/w[i];
        P += p[i];
        W += w[i];
    }
    if(W <= c)
        return P; // 装入所有物品
    Sort(Q,n); // 按物品单位重量价值排序(从大到小)
    Knap<Typew,Typep> K;
    K.p = new Typep[n+1];
    K.w = new Typew[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.Backtrace(1); //回溯搜索
    delete[] Q;
    delete[] K.w;
    delete[] K.p;
    return K.bestp;
}

【实例算法(害,偷个懒)】

// n=5, c=10, w={2, 2, 6, 5, 4}, v={6, 3, 5, 4, 6}的0-1背包问题的最优解和最优值。
#include <iostream>
using namespace std;

#define N 10
int w[N];//重量
int v[N];//价值
int x[N];//1表放入背包,0表不放入
int n,c;//n:物品个数 c:背包的最大容量

int cw=0;//当前物品总重
int cv=0;//当前物品总价值

int bestp=0;//当前最大价值
int bestx[N];//最优解

//回溯函数 k表示当前处在第几层做选择,k=1时表示决定是否将第一个物品放入背包
void backtrack(int k)
{//叶子节点,输出结果
   if(k>n){//找到一个更优的解
     if(cv>bestp){//保存更优的值和解
        bestp = cv;
        for(int i=1; i<=n; i++)
            bestx[i] = x[i];
        }
    }
   else{//遍历当前节点的子节点
     for(int i=0; i<=1; i++){
        x[k]=i;
        if(i==0){
            backtrack(k+1);
        }
        else{//约束条件:当前物品是否放的下
           if((cw+w[k])<=c){
             cw += w[k];
             cv += v[k];
             backtrack(k+1);
             cw -= w[k];
             cv -= v[k];
           }
        }
     }
  }
}

int main()
{

    cout<<"请输入物品的个数:";
    cin>>n;
    cout<<"请输入每个物品的重量及价值:"<<endl;
    for(int i=1;i<=n;i++)
    {
        cin>>w[i]>>v[i];
    }
    cout<<"请输入背包的限制容量:";
    cin>>c;
    backtrack(1);
    cout<<"最优值是:"<<bestp<<endl;
    cout<<"(";
    for(int i=1;i<=n;i++)
        cout<<bestx[i]<<" ";
    cout<<")";
    return 0;
}

结果:

 【时间和空间复杂度分析】

计算上界Bound()函数需要O(n)时间,在最坏的情况下有O(2^n)个右子节点需要计算上界,所以解0-1背包的回溯算法法BackTrack需要的计算时间为O(n2^n)实际上,最坏情况下,剪枝并不会改变时间复杂度。个人感觉0-1背包还是动态规划算法比较好吧。

  • 136
    点赞
  • 823
    收藏
    觉得还不错? 一键收藏
  • 23
    评论
0-1背包问题是一个经典的组合优化问题,它的目标是在给定的一组物品中选择一些物品放入容量为C的背包中,使得背包中物品的总价值最大。这个问题可以使用回溯法来解决。 回溯法是一种通过搜索所有可能的解来求解问题的方法。在0-1背包问题中,我们可以使用回溯法来搜索所有可能的解向量Xi,然后选择其中价值最大的解向量作为最终的解。 具体来说,我们可以按照以下步骤来设计回溯法算法: 1. 定义一个解向量X,其中Xi表示第i个物品是否放入背包中。 2. 定义一个变量max_value,用于记录当前找到的最大价值。 3. 从第一个物品开始,依次考虑将其放入背包或不放入背包的情况。 4. 对于每种情况,计算当前的总价值,并与max_value进行比较。如果当前总价值大于max_value,则更新max_value。 5. 如果当前物品不是最后一个物品,则递归考虑下一个物品。 6. 如果当前物品是最后一个物品,则返回当前的总价值。 在实际实现中,我们可以使用一个递归函数来实现上述算法。具体来说,递归函数的参数包括当前的物品编号、当前的解向量X、当前的总重量和总价值、背包的容量C、以及当前找到的最大价值max_value。递归函数的返回值为当前的总价值。 下面是一个使用回溯法解决0-1背包问题的Python代码示例: ```python def backtrack(i, X, weight, value, C, max_value): if i == len(X): return value # 不放第i个物品 value1 = backtrack(i+1, X, weight, value, C, max_value) # 放第i个物品 if weight[i] <= C: X[i] = 1 value2 = backtrack(i+1, X, weight, value+value[i], C-weight[i], max_value) X[i] = 0 max_value = max(max_value, value2) return max(value1, max_value) # 测试代码 weight = [2, 3, 4, 5] value = [3, 4, 5, 6] C = 8 X = [0] * len(weight) max_value = backtrack(0, X, weight, 0, C, 0) print(max_value) ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 23
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值