回溯法求解0/1背包问题的算法

于 2023-03-17 16:00:03 发布
阅读量516 收藏 2
点赞数
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/T13629119629/article/details/111187256
版权
这段代码展示了如何使用动态规划和回溯法来解决0/1背包问题，通过按价值密度排序物品并计算节点的上界，找到能最大化效益的物品组合。程序包括了只输出最优效益值的版本和同时输出最优解和最优值的版本。还包含了性能测试代码，用于测量排序和回溯算法的执行时间。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这个代码含有检查的代码片段

#include <stdio.h>
#include <stdlib.h>

int n,c,p[20],w[20],x[20],bestp=-1,cw[21],cp[21],isdown=1;//分别是背包容量，物品重量，价值，装入背包与否。当前最优效益值，目前装入背包的物品总重量，目前装入背包的物品总效益值。
double bound[21];//当前节点的上界
double p1[20],w1[20];
void sort (int n,int p[20],int w[20]) //按价值密度排序
{
    int j,h,k;
    double t1,t2,t3,q[20];
    for(k=1;k<=n;k++)
        p1[k]=p[k];
    for(k=1;k<=n;k++)
        w1[k]=w[k];
    for(k=1;k<=n;k++)
        q[k]=p1[k]/w1[k];
    for(h=1;h<n;h++)
        for(j=1;j<=n-h;j++)
        if(q[j]<q[j+1])
        {
            t1=p1[j];p1[j]=p1[j+1];p1[j+1]=t1;
            t2=w1[j];w1[j]=w1[j+1];w1[j+1]=t2;
            t3=q[j];q[j]=q[j+1];q[j+1]=t3;
        }
    for(int j=1;j<=n;j++)
    {
        p[j]=p1[j];
    }
    for(int j=1;j<=n;j++)
    {
        w[j]=w1[j];
    }
    for(int j=1;j<=n;j++)
    {
        printf("%d ",p[j]);
    }
    printf("\n");
    for(int j=1;j<=n;j++)
    {
        printf("%d ",w[j]);
    }
    printf("\n");
}
double Bound(int k)
{
    double m;
    if(x[k]==1)
    {
        bound[k]=bound[k-1];
    }
    else
    {   m=c-cw[k];
        bound[k]=cp[k];
        if(k<n)
        for(int i=1;i<=n;i++)
        {

            if(w[k+i]<=m)
            {
                bound[k]+=p[k+i];
                m-=w[k+i];
            }
            else
            {
                bound[k]+=m/w[k+i]*p[k+i];
                break;
            }
        }
    }
    return bound[k];
}
void BackTrack(int i)//看物品i是否可放入背包
{
    if(i==n+1)
    {
        printf("*%d\n",i);
        if(cp[i-1]>bestp)
            {bestp=cp[i-1];printf("%d",bestp);}
        isdown=0;
        BackTrack(i-1);
    }
    else if(isdown==0&&x[i]==0)
    {
        printf("$%d %d %d",i,x[i-1],x[7]);
        if(i-1>=1)
           BackTrack(i-1);
    }

    else if(bound[i-1]>bestp){
            printf("^");
        if(isdown==1&&cw[i-1]+w[i]<=c)
        {
            x[i]=1;
            cw[i]=cw[i-1]+w[i];
            printf("n%d %dn",w[i],c);
            cp[i]=cp[i-1]+p[i];
            bound[i]=Bound(i);
        }
        else
        {

                 x[i]=0;
                 cw[i]=cw[i-1];
                 cp[i]=cp[i-1];
                 bound[i]=Bound(i); printf("@%d %lf@",w[i],bound[i]);
        }
        isdown=1;
        BackTrack(i+1);
    }
        else if(i-1>=1)
        {
            isdown=0;
            BackTrack(i-1);
            printf("~");
        }
}


int main()
{
    scanf("%d%d",&n,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
        x[i]=-1;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i]);
    }
    sort( n, p, w);
    cw[0]=0;
    cp[0]=0;
    bound[0]=0;double d=0;
    for(int i=1;i<=n;i++)
    {
        if(d+w[i]<=c)
        {
            bound[0]+=p[i];
            d+=w[i];
        }
        else
        {
            bound[0]+=(c-d)/w[i]*p[i];
            break;
        }
    }
    printf("#%lf",bound[0]);
    BackTrack(1);
    printf("%d\n",bestp);
    return 0;

}

在这里插入图片描述
这个是只输出最后结果的代码：

#include <stdio.h>
#include <stdlib.h>

int n,c,p[20],w[20],x[20],bestp=-1,cw[21],cp[21],isdown=1;//分别是物品数量，背包容量，物品价值，重量，装入背包与否。当前最优效益值，目前装入背包的物品总重量，目前装入背包的物品总效益值。判断是否回溯
double bound[21];//当前节点的上界
double p1[20],w1[20];
void sort (int n,int p[20],int w[20]) //按价值密度从大到小排序
{
    int j,h,k;
    double t1,t2,t3,q[20];
    for(k=1;k<=n;k++)
        p1[k]=p[k];
    for(k=1;k<=n;k++)
        w1[k]=w[k];
    for(k=1;k<=n;k++)
        q[k]=p1[k]/w1[k];
    for(h=1;h<n;h++)
        for(j=1;j<=n-h;j++)
        if(q[j]<q[j+1])
        {
            t1=p1[j];p1[j]=p1[j+1];p1[j+1]=t1;
            t2=w1[j];w1[j]=w1[j+1];w1[j+1]=t2;
            t3=q[j];q[j]=q[j+1];q[j+1]=t3;
        }
    for(int j=1;j<=n;j++)
    {
        p[j]=p1[j];
    }
    for(int j=1;j<=n;j++)
    {
        w[j]=w1[j];
    }
}
double Bound(int k)//确定当前结点对应的上界
{
    double m;
    if(x[k]==1)//若该节点是父节点的左子节点，则继续展开该节点的上效益值界等于它的父节点的上界
    {
        bound[k]=bound[k-1];
    }
    else//若该节点是父节点的右子节点，则继续展开该节点的效益值上界等于展开到该节点的总效益值加上贪心法得到的其余物品的连续背包问题的优化效益值
    {   m=c-cw[k];//背包剩余容量
        bound[k]=cp[k];//k=n时，即判断展开叶子结点的上界，显然等于展开到叶子结点的总效益值，因为叶子结点不能再展开
        if(k<n)
        for(int i=1;i<=n;i++)
        {

            if(w[k+i]<=m)//先判断k结点后的节点k+i结点的重量是否可装进包里
            {
                bound[k]+=p[k+i];//若可装入，则展开k结点的效益值上界就再加上第k+i个物品的效益值
                m-=w[k+i];//装入第k+i个物品后，背包可容纳重量减去第k+i个物品的重量
            }
            else//到第k+i个物品时，不能装入背包
            {
                bound[k]+=m/w[k+i]*p[k+i];//由于求bound时，是看作连续背包问题，所以这里可以加上第k+i个物品可装入背包的那一部分的效益值
                break;//到此为止，找到继续展开k结点的效益值上界
            }
        }
    }
    return bound[k];
}
void BackTrack(int i)//物品i放入背包的情况
{
    if(i==n+1)//此时已经展开到叶子结点了，不能继续展开了
    {
        if(cp[i-1]>bestp)//到叶子结点需更新bestp，若展开到叶子结点的元组对应的总效益值大于当前bestp，则更新bestp值为叶子节点的cp
            {bestp=cp[i-1];}
        isdown=0;//由于不能继续展开叶子结点，所以要回溯到它的父节点，此时要有标记回溯的变量isdown（isdown=0表示回溯，=1表示继续展开该节点）
        BackTrack(i-1);//回溯到父节点
    }
    else if(isdown==0&&x[i]==0)//回溯到父节点i且父节点已经展开左子和右子结点
    {
        if(i-1>=1)//如果i结点不是根节点，则继续回溯
           BackTrack(i-1);
    }
    //以下可以表示从上到下展开到i结点，也可以表示从下到上回溯到i结点，若是回溯，（有上个else if）可知i结点只展开了左子节点
    else if(bound[i-1]>bestp){//bound[i-1]表示继续展开i结点的效益值上界，此时可以展开i结点
        if(isdown==1&&cw[i-1]+w[i]<=c)//表示从上到下展开到i结点并且可以继续展开i结点，由上到下是先展开左子节点
        {
            x[i]=1;
            cw[i]=cw[i-1]+w[i];
            cp[i]=cp[i-1]+p[i];
            bound[i]=Bound(i);
        }
        //以下可以是从上到下展开到i结点，此时肯定第i个物品无法装入背包所以展开的是结点的右子结点
        //若是从下到上展开到i结点，由上面分析知道肯定i结点只展开了左子节点，则这里直接展开右子结点
        else
        {

                 x[i]=0;
                 cw[i]=cw[i-1];
                 cp[i]=cp[i-1];
                 bound[i]=Bound(i);
        }
        isdown=1;//下面要继续向下展开i+1结点，所以这里isdown标记为1
        BackTrack(i+1);//向下展开i+1结点
    }
        else if(i-1>=1)//bound[i-1]<=bestp，相当于i结点被限界，即不能继续展开i结点，且i结点不是根节点，则回溯到i节点的父节点
        {
            isdown=0;
            BackTrack(i-1);
        }
}
//上述是个递归地过程，不断地调用BackTrack可以展开状态空间树得到最优解。

int main()
{
    scanf("%d%d",&n,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
        x[i]=-1;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i]);
    }
    sort( n, p, w);
    cw[0]=0;
    cp[0]=0;
    bound[0]=0;double d=0;
    for(int i=1;i<=n;i++)//计算bound[0]
    {
        if(d+w[i]<=c)
        {
            bound[0]+=p[i];
            d+=w[i];
        }
        else
        {
            bound[0]+=(c-d)/w[i]*p[i];
            break;
        }
    }
    BackTrack(1);//展开状态空间树
    printf("%d\n",bestp);//输出最优效益值
    return 0;

}

在这里插入图片描述
下面是既有输出最优解又有输出最优值程序：

#include <stdio.h>
#include <stdlib.h>

int n,c,p[20],w[20],x[20],x2[20],b[20],bestp=-1,cw[21],cp[21],isdown=1;//分别是物品数量，背包容量，物品价值，重量，装入背包与否。当前最优效益值，目前装入背包的物品总重量，目前装入背包的物品总效益值。判断是否回溯
double bound[21];//当前节点的上界
double p1[20],w1[20];
void sort (int n,int p[20],int w[20]) //按价值密度从大到小排序
{
    int j,h,k;
    double t1,t2,t3,t,q[20];
    for(k=1;k<=n;k++)
        p1[k]=p[k];
    for(k=1;k<=n;k++)
        w1[k]=w[k];
    for(k=1;k<=n;k++)
        q[k]=p1[k]/w1[k];
    for(h=1;h<n;h++)
        for(j=1;j<=n-h;j++)
        if(q[j]<q[j+1])
        {
            t1=p1[j];p1[j]=p1[j+1];p1[j+1]=t1;
            t2=w1[j];w1[j]=w1[j+1];w1[j+1]=t2;
            t3=q[j];q[j]=q[j+1];q[j+1]=t3;
            t=b[j];b[j]=b[j+1];b[j+1]=t;
        }
    for(int j=1;j<=n;j++)
    {
        p[j]=p1[j];
    }
    for(int j=1;j<=n;j++)
    {
        w[j]=w1[j];
    }
}
double Bound(int k)//确定当前结点对应的上界
{
    double m;
    if(x[k]==1)//若该节点是父节点的左子节点，则继续展开该节点的上效益值界等于它的父节点的上界
    {
        bound[k]=bound[k-1];
    }
    else//若该节点是父节点的右子节点，则继续展开该节点的效益值上界等于展开到该节点的总效益值加上贪心法得到的其余物品的连续背包问题的优化效益值
    {   m=c-cw[k];//背包剩余容量
        bound[k]=cp[k];//k=n时，即判断展开叶子结点的上界，显然等于展开到叶子结点的总效益值，因为叶子结点不能再展开
        if(k<n)
        for(int i=1;i<=n;i++)
        {

            if(w[k+i]<=m)//先判断k结点后的节点k+i结点的重量是否可装进包里
            {
                bound[k]+=p[k+i];//若可装入，则展开k结点的效益值上界就再加上第k+i个物品的效益值
                m-=w[k+i];//装入第k+i个物品后，背包可容纳重量减去第k+i个物品的重量
            }
            else//到第k+i个物品时，不能装入背包
            {
                bound[k]+=m/w[k+i]*p[k+i];//由于求bound时，是看作连续背包问题，所以这里可以加上第k+i个物品可装入背包的那一部分的效益值
                break;//到此为止，找到继续展开k结点的效益值上界
            }
        }
    }
    return bound[k];
}
void BackTrack(int i)//物品i放入背包的情况
{
    if(i==n+1)
    {
        if(cp[i-1]>bestp)
            {
                bestp=cp[i-1];
                for(int i=1;i<=n;i++)
                {
                    x2[b[i]]=x[i];
                }
            }
        isdown=0;
        BackTrack(i-1);
    }
    else if(isdown==0&&x[i]==0)
    {
        if(i-1>=1)
           BackTrack(i-1);
    }
    //以下可以表示从上到下展开到i结点，也可以表示从下到上回溯到i结点，若是回溯，（有上个else if）可知i结点只展开了左子节点
    else if(bound[i-1]>bestp){//bound[i-1]表示继续展开i结点的效益值上界，此时可以展开i结点
        if(isdown==1&&cw[i-1]+w[i]<=c)//表示从上到下展开到i结点并且可以继续展开i结点，由上到下是先展开左子节点
        {
            x[i]=1;
            cw[i]=cw[i-1]+w[i];
            cp[i]=cp[i-1]+p[i];
            bound[i]=Bound(i);
        }
        //以下可以是从上到下展开到i结点，此时肯定第i个物品无法装入背包所以展开的是结点的右子结点
        //若是从下到上展开到i结点，由上面分析知道肯定i结点只展开了左子节点，则这里直接展开右子结点
        else
        {

                 x[i]=0;
                 cw[i]=cw[i-1];
                 cp[i]=cp[i-1];
                 bound[i]=Bound(i);
        }
        isdown=1;//下面要继续向下展开i+1结点，所以这里isdown标记为1
        BackTrack(i+1);//向下展开i+1结点
    }
        else if(i-1>=1)//bound[i-1]<=bestp，相当于i结点被限界，即不能继续展开i结点，且i结点不是根节点，则回溯到i节点的父节点
        {
            isdown=0;
            BackTrack(i-1);
        }
}
//上述是个递归地过程，不断地调用BackTrack可以展开状态空间树得到最优解。

int main()
{
    scanf("%d%d",&n,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
        x[i]=-1;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i]);
    }
    for(int i=1;i<=n;i++)
        b[i]=i;
    sort( n, p, w);
    cw[0]=0;
    cp[0]=0;
    bound[0]=0;double d=0;
    for(int i=1;i<=n;i++)//计算bound[0]
    {
        if(d+w[i]<=c)
        {
            bound[0]+=p[i];
            d+=w[i];
        }
        else
        {
            bound[0]+=(c-d)/w[i]*p[i];
            break;
        }
    }
    BackTrack(1);//展开状态空间树
    printf("%d\n",bestp);//输出最优效益值
    for(int i=1;i<=n;i++)
        printf("%d ",x2[i]);
    printf("\n");
    return 0;

}

运行结果：
在这里插入图片描述
以下包含测试算法性能的代码片段：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <iostream>
using namespace std;
int n,c,p[30],w[30],x[30],x2[30],b[30],bestp=-1,cw[31],cp[31],isdown=1;
int count=0;
double bound[31];//当前节点的上界
double p1[30],w1[30];
void sort (int n,int p[30],int w[30]) //按价值密度从大到小排序
{
    int j,h,k;
    double t1,t2,t3,t,q[30];
    for(k=1;k<=n;k++)
        p1[k]=p[k];
    for(k=1;k<=n;k++)
        w1[k]=w[k];
    for(k=1;k<=n;k++)
        q[k]=p1[k]/w1[k];
    for(h=1;h<n;h++)
        for(j=1;j<=n-h;j++)
        if(q[j]<q[j+1])
        {
            t1=p1[j];p1[j]=p1[j+1];p1[j+1]=t1;
            t2=w1[j];w1[j]=w1[j+1];w1[j+1]=t2;
            t3=q[j];q[j]=q[j+1];q[j+1]=t3;
            t=b[j];b[j]=b[j+1];b[j+1]=t;
        }
    for(int j=1;j<=n;j++)
    {
        p[j]=p1[j];
    }
    for(int j=1;j<=n;j++)
    {
        w[j]=w1[j];
    }
}
double Bound(int k)//确定当前结点对应的上界
{
    double m;
    if(x[k]==1)
    {
        bound[k]=bound[k-1];
    }
    else
    {   m=c-cw[k];//背包剩余容量
        bound[k]=cp[k];
        if(k<n)
        for(int i=1;i<=n;i++)
        {

            if(w[k+i]<=m)
            {
                bound[k]+=p[k+i];
                m-=w[k+i];
            }
            else
            {
                bound[k]+=m/w[k+i]*p[k+i];
                break;
            }
        }
    }
    return bound[k];
}

void BackTrack(int i)
{
    count++;
    if(i==n+1)
    {
        if(cp[i-1]>bestp)
            {
                bestp=cp[i-1];
                for(int i=1;i<=n;i++)
                {
                    x2[b[i]]=x[i];
                }
            }
        isdown=0;
        BackTrack(i-1);
    }
    else if(isdown==0&&x[i]==0)
    {
        if(i-1>=1)
           BackTrack(i-1);
    }

    else if(bound[i-1]>bestp){
        if(isdown==1&&cw[i-1]+w[i]<=c)
        {
            x[i]=1;
            cw[i]=cw[i-1]+w[i];
            cp[i]=cp[i-1]+p[i];
            bound[i]=Bound(i);
        }

        else
        {

                 x[i]=0;
                 cw[i]=cw[i-1];
                 cp[i]=cp[i-1];
                 bound[i]=Bound(i);
        }
        isdown=1;
        BackTrack(i+1);
    }
        else if(i-1>=1)
        {
            isdown=0;
            BackTrack(i-1);
        }

}

int main()
{
    double time=0;
    LARGE_INTEGER nFreq;
    LARGE_INTEGER nBeginTime;
    LARGE_INTEGER nEndTime;
    QueryPerformanceFrequency(&nFreq);

    scanf("%d%d",&n,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
        x[i]=-1;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i]);
    }
    for(int i=1;i<=n;i++)
        b[i]=i;
    QueryPerformanceCounter(&nBeginTime);
    sort( n, p, w);
    QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
    printf("sort执行时间：%lf ms\n",time*1000);
    cw[0]=0;
    cp[0]=0;
    bound[0]=0;double d=0;
    for(int i=1;i<=n;i++)//计算bound[0]
    {
        if(d+w[i]<=c)
        {
            bound[0]+=p[i];
            d+=w[i];
        }
        else
        {
            bound[0]+=(c-d)/w[i]*p[i];
            break;
        }
    }
    QueryPerformanceCounter(&nBeginTime);
    BackTrack(1);
    QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
    printf("BackTrack执行时间：%lf ms\n",time*1000);
    printf("最优效益值：%d\n",bestp);
    for(int i=1;i<=n;i++)
        printf("%d ",x2[i]);
    printf("\n");
    printf("递归调用次数：%d\n",count);
    return 0;

}
夏日流萤
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值