【动态规划】完全背包问题

点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃

1. 完全背包

题目链接： DP42 【模板】完全背包

题目分析：

上面题目描述和01背包的一样，这里不在叙述。直接来看示例。

算法原理：

解决第一问背包没有必要装满的情况

之前在01背包哪里说过其他背包问题都是从01背包延伸的，所以01背包是其他背包的基础。接下来的状态表示、状态转移方程等全都是按照01背包来的。

1.状态表示

dp[i][j] 表示：从前 i 个物品中选，总体积不超过 j ，所有选法中，最大价值是多少。

2.状态转移方程

这里也是和01背包那里一样，根据最后一个位置，划分情况。
但是这里有点差别，01背包哪里只有选or不选两个情况，我们这里情况就多了。可以不选、可以选1个、可以选2个、可以选3个…

不选 i，说明所有选法中都不包含第 i 个物品，相当于从去 1 ~ i - 1 这个区间去选，就是dp[i-1][j]

选一个 i，这时就有一个v[i]的体积了，然后仅需去 1 ~ i - 1 区间去选一个 不超过j - v[i]的最大价值，然后在加上 i 的价值。

选两个 i，这时就有两个v[i]的体积了，然后仅需去 1 ~ i - 1 区间去选一个 不超过j - 2*v[i]的最大价值，然后在加上两个 i 的价值。

选三个 i，选四个…，同理如上。

如果做过前面的通配符匹配和正则表达式的时候，我们是遇到这种状态转移方程的。发现填一个状态的时候发现这个状态时候很多状态拼接而成的，这个时候我们要想到策略把这些状态用一个或者两个状态来表示。

优化：数学

假设最后选了k个i，在选背包容量就装不下了。

我们发现 i - 1 是没有变的，但是 j 是均匀减v[i]，所以我们可以转化一下

先分析一下，k和x是否相等。上面的k表示，j - kv[i] 无限接近于0，下面的x其实也是表示，j - xv[i] 无线接近于0。所以 k == x，也就说上面划线的和下面的个数是完全相同的。

然后我们给下面的加上一个w[i]，你会发现上面划线的完全可以用下面的替代。

因此我们就可以得到优化后的dp[i][j]的状态转移方程。
注意 j - v[i] 可能不存在，这里和01背包一样，所以必须 j >= v[i]

3.初始化

多开一行一列

1. 里面的值要保证后序的填表是正确的
2. 下标的映射关系

第一列不用初始化前面01背包应用已经解释过了。
第一行表示物品为空，当 j 为0的时候，要凑成不超过 j，只要不选就行了，最大价值是0。如果j为1、2、3但是没有物品可选，同样最大价值也是0.

4.填表

填dp[i][j]会用到上面和左边的值，因此从上往下填写每一行，每一行从左往右。

5.返回值

dp[i][j] 表示：从前 i 个物品中选，总体积不超过 j ，所有选法中，最大价值是多少。我们要的是从整个物品中选不超过V的最大价值。因此返回dp[n][V]

解决第二问背包必须装满的情况。

在之前的基础上稍加修改就行

1.状态表示

2.状态转移方程

这里稍微修改的是dp[i][j-v[i]] + w[i]，我们之前只是判断 j - v[i] 是否存在。因为我们这里是必须要装满，但是dp[i][j-v[i]]不一定装满。如果不一定装满用0表示的话，因为后面加个w[i]，dp[i][j]求max就可能会用到这个状态。但是实际上要求如果dp[i][j-v[i]]凑不够是不能用dp[i][j-v[i]] + w[i]。所以不仅要判断 j >= v[i]，还要判断dp[i][j-v[i]情况是否存在。我们这里和01背包哪里一样，用dp[i][j] == -1 表示情况不存在，没有这个状态。根本凑不出来 j - v[i]的体积。为什么不用0，因为第一行第一个空格dp[0][0] == 0 表示没有物品，j 等于0，只要不选就行了，是有这种情况的。最大价值是0。

3.初始化

这里我们处理第一行就行了，第一列还是不用初始化

第一行为空，表示没有物品，没有物品此时 j 为 0，不选就行了，此时最大价值为0。那没有物品肯定凑不成 j 为 1、2、3…等情况，给 -1.

4.填表

5.返回值

注意如果最终结果是-1，说明物品凑不出V的情况要返回0，因此返回之前要判断一下

#include <iostream>
#include<cstring>
using namespace std;

const int N = 1010;
int n,V,v[N],w[N];
int dp[N][N];

int main()
{
    // 读入数据
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];

    // 第一问
    for(int i = 1; i <= n; ++i)
        for(int j = 0; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i])
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    cout<<dp[n][V]<<endl;

    //  第二问
    memset(dp,0,sizeof dp);
    for(int j = 1; j <= V; ++j) dp[0][j] = -1;

    for(int i = 1; i <= n; ++i)
        for(int j = 0; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    cout<<(dp[n][V] == -1 ? 0 : dp[n][V])<<endl;
  
}

优化：

填写 dp[i][j] 需要上一行和同一行前面的位置

我们搞成一个数组，直接把横坐标 i 干掉。如果填 j 位置，也需要之前上一行的状态和同一行前面的状态，因此从左往右遍历。

#include <iostream>
#include<cstring>
using namespace std;

const int N = 1010;
int n,V,v[N],w[N];
//int dp[N][N];
int dp[N];

int main()
{
    // 读入数据
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];

    // // 第一问
    // for(int i = 1; i <= n; ++i)
    //     for(int j = 0; j <= V; ++j)
    //     {
    //         dp[i][j] = dp[i - 1][j];
    //         if(j >= v[i])
    //             dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
    //     }
    // cout<<dp[n][V]<<endl;

    // //  第二问
    // memset(dp,0,sizeof dp);
    // for(int j = 1; j <= V; ++j) dp[0][j] = -1;

    // for(int i = 1; i <= n; ++i)
    //     for(int j = 0; j <= V; ++j)
    //     {
    //         dp[i][j] = dp[i - 1][j];
    //         if(j >= v[i] && dp[i][j - v[i]] != -1)
    //             dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
    //     }
    // cout<<(dp[n][V] == -1 ? 0 : dp[n][V])<<endl;

    //优化

    // 第一问
    for(int i = 1; i <= n; ++i)
        for(int j = v[i]; j <= V; ++j)//把if判断写到循环，直接从j = v[i]开始
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    cout<<dp[V]<<endl;

    //  第二问
    memset(dp,0,sizeof dp);
    for(int j = 1; j <= V; ++j) dp[j] = -1;
    for(int i = 1; i <= n; ++i)
        for(int j = v[i]; j <= V; ++j)
            if(dp[j - v[i]] != -1)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
     cout<<(dp[V] == -1 ? 0 : dp[V])<<endl;
     return 0;
}

优化的完全背包代码如果和01背包代码相比，你会发现它们俩只有遍历顺序不一样，01背包是从 V -> v[i]，完全背包是从 v[i] -> V，其他代码都是一样的。

其实这里还有一点点优化，有的人这里不用判断if，发现它的代码也过了。

我们这里放个if，主要是为了防止dp[j-v[i]] + w[i]不合法就用了，所以加了一个if。其实不加if也可以做到，合法用，不合法不用。因为这里求的是max，我只要让它不合法的时候值足够小就行了，即使求max它也没有用。

如何才能让它足够小呢？
我们可以初始第一行不给它设为-1，因为-1加一个正数可能是一个正数。而是设置为0x3f3f3f3f。首先这个数足够小，其次这个数用来做加法极有可能不会超过0。如果你设置为INT_MIN，如果是 - w[i] 就会溢出，溢出之后就会变成一个非常大的正数。

最后判断也要改一下。

#include <iostream>
#include<cstring>
using namespace std;

const int N = 1010;
int n,V,v[N],w[N];
//int dp[N][N];
int dp[N];

int main()
{
    // 读入数据
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];


    //优化

    // 第一问
    for(int i = 1; i <= n; ++i)
        for(int j = v[i]; j <= V; ++j)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    cout<<dp[V]<<endl;

    //  第二问
    // memset(dp,0,sizeof dp);
    // for(int j = 1; j <= V; ++j) dp[j] = -1;
    // for(int i = 1; i <= n; ++i)
    //     for(int j =  v[i]; j <= V; ++j)
    //         if(dp[j - v[i]] != -1)
    //             dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    // cout<<(dp[V] < 0 ? 0 : dp[V])<<endl;

    for(int j = 1; j <= V; ++j) dp[j] = -0x3f3f3f3f;
    for(int i = 1; i <= n; ++i)
        for(int j =  v[i]; j <= V; ++j)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

    cout<<(dp[V] < 0 ? 0 : dp[V])<<endl;

}