ACM算法笔记(三)背包问题_01背包

首发csdn,链接:https://blog.csdn.net/Colicsin/article/details/115403831

问题描述:

*现在给你一个容量为V的背包,有N个物品,其中第i件物品的重量为wi,价值为vi,每件物品只可以拿一次,问在有限的容量内,最多可以拿到多少价值的物品。 *

问题分析:

对于每一个物品,都有两种策略:拿或不拿。

读到这里,是不是脑海中有一个清晰的想法?DFS!确实,这不就是我们常见的dfs问题吗,分别枚举拿和不拿两个状态即可。于是写下了如此代码...

#include
#include
#include
using namespace std;
const int MAXN=1e6+7;
int w[MAXN],N,V,v[MAXN],book[MAXN],end=0;
void dfs(int now,int ans,int rest_v)
{
    if(now>N)
    {
        end=max(ans,end);
        return;
    }
    if(book[now]==false&&rest_v>=w[now])
    {
        ans+=v[now];
        rest_v-=w[now];
        book[now]=true;
        dfs(now+1,ans,rest_v);
        ans-=v[now];
        rest_v+=w[now];
        book[now]=false;
    }
    dfs(now+1,ans,rest_v);
}
int main()
{
    cin>>V>>N;
    for(int i=1;i<=N;i++)
    {
        cin>>w[i]>>v[i];
    }
    dfs(1,0,V);
    cout<

很遗憾对于洛谷P1048的01背包模板题来说,只有30分,剩下70分全部都是TLE(这是什么人间疾苦!)

点此访问洛谷P1048

不过转念一想好像确实,我们平常dfs模板的代码不就是解决小数据问题的么,对于中等数据量和大数据问题,不会吧不会吧不会吧,不会真的有人想写dfs吧?(老阴阳怪气了)

现在我们手动模拟一下...

很显然,当n特别大的时候(我觉得到100之后就已经够呛了)我们的程序变得特别慢,难免TLE(原来是自己老了哈哈哈哈)

不过,车到山前必有路,我们观察这棵横着的递归树,发现是不是有很多重复遍历的部分?

比如选3,选4这个小方案,在选1,选2、选1不选2、不选1选2、不选1不选2的时候都需要访问一次,现在还只是有4个物品的情况,要是有n个物品,那岂不是2^n的数量级了?实在可怕,这样一想,我们之前的代码TLE的关键原因也出来了,就是重复遍历的太多了。

这时候我们就需要一个maxn_数组来辅助剪枝一下,maxn_[i][j]表示前i个物品还剩j点空间下能存放的物品价值的最大值,设想我们现在从不选1选2走到了选3选4这条路上,但是发现还没走之前所选物品的值已经比其他的路到达选3选4的路时所选的物品的值小了,那这条路我们还有必要去走嘛?Ofcourse not!所以就直接return就好咯,这样子就完成了剪枝任务bingo!

如果折现回到代码上,是这样子...

#include
#include
#include
using namespace std;
const int MAXN=1e6+7;
int w[MAXN],N,V,v[MAXN],book[MAXN],end=0,maxn_[1001][1001];
void dfs(int now,int ans,int rest_v)
{
    if(ans<=maxn_[now][rest_v])
        return;
    maxn_[now][rest_v]=ans;
    if(now>N)
    {
        end=max(ans,end);
        return;
    }
    if(book[now]==false&&rest_v>=w[now])
    {
        ans+=v[now];
        rest_v-=w[now];
        book[now]=true;
        dfs(now+1,ans,rest_v);
        ans-=v[now];
        rest_v+=w[now];
        book[now]=false;
    }
    dfs(now+1,ans,rest_v);
}
int main()
{
    cin>>V>>N;
    memset(maxn_,-1,sizeof(maxn_));
    for(int i=1;i<=N;i++)
    {
        cin>>w[i]>>v[i];
    }
    dfs(1,0,V);
    cout<

不过比起递归,01背包最好的方式还是递推,这也是为什么01背包能当作动态规划初步引入例题的原因了。

我们假设dp[i][j]表示前i件物品用j的容量去装,所能达到的最大价值。(是不是很熟悉?没错,就是刚才记忆化搜索用到的那个判断继续不继续的标准)

对于每一次决策,有两个状态:选或不选

对于每一个状态的值,都依赖于上一个状态的值

满足动态规划的条件√

很容易写出状态转移方程:

dp[i][j]=min(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);

说得更清楚一些,dp[i-1][j]不就代表这一件不选,那么就相当于前i-1件物品放入j容量的背包的最大价值,dp[i-1][j-w[i]]代表这一件要了,前i-1件物品放入j-w[i]的容量内的最大价值。

因此我们可以写出以下代码....

#include
#include
#include
using namespace std;
const int MAXN=1e3+7;
int w[MAXN],N,V,v[MAXN],dp[MAXN][MAXN];
int main()
{
    memset(dp,0,sizeof(dp));
    cin>>V>>N;
    for(int i=1;i<=N;i++)
    {
        cin>>w[i]>>v[i];
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=0;j--)
        {
            if(j>=w[i])
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);
            else
                dp[i][j]=dp[i-1][j];
        }
    }
    cout<

但是事情就到这里就结束了吗?当然没有!

没错,还可以接着优化!时间优化?并不,空间优化。毕竟二维数组还是很坑的,万一比赛碰到了一些“善良的死神”,直接MLE了....

从上面我们分析注意到,每一层i的状态都和上一层i-1的状态有关,这样子我们是不是并不需要开二维数组呢?这个时候,滚动数组闪亮出场~

啥是滚动数组?这还要从头忆起,说简单点,滚动数组就是一个很小的数组,一直滚...一直滚...好吧其实就是不断更新的数组。

这里用斐波那契数列来举例子确实再好不过,因为斐波那契数列第i项就是前两项之和,所以对于斐波那契数列来说,有以下代码...

f[1]=1;
f[2]=1;
for(int i=2;i<=n;i++)
{
    f[0]=f[1];
    f[1]=f[2];
    f[2]=f[0]+f[1];
}

这样子最后f[n]就是第n项的值咯~

从滚动数组得到经验,我们用滚动数组来优化我们的二维dp代码...

#include
#include
#include
using namespace std;
const int MAXN=1e3+7;
int w[MAXN],N,V,v[MAXN],dp[100001];
int main()
{
    memset(dp,0,sizeof(dp));
    cin>>V>>N;
    for(int i=1;i<=N;i++)
    {
        cin>>w[i]>>v[i];
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=0;j--)
        {
            if(j>=w[i])
                dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
        }
    }
    cout<

Ps:对于一维数组,j循环必须要倒序遍历,为了防止多重迭代现象;

举个小例子;

假设给定数据:

10 3

5 5

8 7

4 6

刚开始数组dp内都是初始化为0,因为没有装入任何东西

第一遍遍历,从前往后

第二遍遍历,从前往后

第三次遍历,从前往后


很显然,出现了什么情况呢?居然最大到了17,这里我们可以看到,根据状态转移方程式dp[j]=max(dp[j],dp[j-w[i]]+v[i])来看,在第三次遍历(i=3),还未遍历时dp[8]=7。开始遍历之后,dp[8]=max(dp[8],dp[4]+v[3]),这个时候发现肯定是dp[4]+v[3]更大一些,但是这个时候要注意,dp[4]是已经拿完了第三件物品的,按理来说,我们并没有办法再去拿第三件物品了,因为每一个物品只能拿一件,所以就行不通咯,自然就不可以用正序的方法。而倒序的方法则是先尽可能地都拿着,在最大化的前提下去判断,自然是可以的。

01背包问题就到此完结

完结撒花,感谢陪伴~

你可能感兴趣的:(ACM算法笔记(三)背包问题_01背包)