DP：完全背包+多重背包问题

于 2024-06-21 11:01:18 发布
阅读量648 收藏 100
点赞数 112
分类专栏： 动态规划算法模型总结 文章标签： 算法 数据结构 动态规划 完全背包 多重背包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51142926/article/details/139535719
版权

完全背包和01背包的区别就是：可以多次选

一、完全背包（模版）

【模板】完全背包_牛客题霸_牛客网

#include <iostream>
#include<string.h>
using namespace std;
const int N=1001;
int n,V,w[N],v[N],dp[N][N];
//dp[i][j]表示从前i个物品选，体积不超过j的最大价值
//dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i],dp[i-1][j-2v[i]]+2w[i]……)
//数学dp[i][j-v[i]]=max(dp[i-1][j-v[i]],dp[i-1][j-2v[i]]+w[i]……)
//dp[i][j]=max(dp[i-1][j],dp[i][j-v[i]])
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=1;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;
    //解决第二问 //dp[i][j]表示从前i个物品选，体积正好为j的最大价值
     memset(dp,0,sizeof dp);
     //约定-1表示状态选不到 当i=0时 j>=1时  必然是没有状态的
     for(int j=1;j<=V;++j) dp[0][j]=-1;
      for(int i=1;i<=n;++i)
    for(int j=1;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;
        return 0;
}

滚动数组的优化策略：

 区分：01背包的优化得是从右往左，而完全背包的优化得是从左往右

#include <iostream>
#include<string.h>
using namespace std;
const int N=1001;
int n,V,w[N],v[N],dp[N];
//dp[i][j]表示从前i个物品选，体积不超过j的最大价值
//dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i],dp[i-1][j-2v[i]]+2w[i]……)
//数学dp[i][j-v[i]]=max(dp[i-1][j-v[i]],dp[i-1][j-2v[i]]+w[i]……)
//dp[i][j]=max(dp[i-1][j],dp[i][j-v[i]])
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;
    //解决第二问 //dp[i][j]表示从前i个物品选，体积正好为j的最大价值
     memset(dp,0,sizeof dp);
     //约定-1表示状态选不到 当i=0时 j>=1时  必然是没有状态的
     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;
     return 0;
}

 二、零钱兑换

. - 力扣（LeetCode）

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        //dp[i][j]表示从前i个里面选 正好凑成j所需要的最少硬币个数
        //如果不选i dp[i-1][j]
        //选1个i   dp[i-1][j-coins[i-1]]+1
        //dp[i][j]=min(dp[i-1][j],dp[i-1][j-coins[i-1]]+1,dp[i-1][j-2coins[i-1]]+2……)
        //dp[i][j-coins[i-1]]=min(dp[i-1][j-coins[i-1]],dp[i-1][j-2coins[i-1]]+1……)
        //dp[i][j]=min(dp[i-1][j],dp[i][j-coins[i-1]]+1)
        const int INF=0x3f3f3f3f;
        int n=coins.size();
        vector<vector<int>> dp(n+1,vector<int>(amount+1));
        for(int j=1;j<=amount;++j) dp[0][j]=INF;
        for(int i=1;i<=n;++i)
          for(int j=1;j<=amount;++j)
           {
            dp[i][j]=dp[i-1][j];
            if(j>=coins[i-1])  dp[i][j]=min(dp[i][j],dp[i][j-coins[i-1]]+1);
           }
         return dp[n][amount]>=INF?-1:dp[n][amount];
    }
};

 滚动数组优化：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        //dp[i][j]表示从前i个里面选 正好凑成j所需要的最少硬币个数
        //如果不选i dp[i-1][j]
        //选1个i   dp[i-1][j-coins[i-1]]+1
        //dp[i][j]=min(dp[i-1][j],dp[i-1][j-coins[i-1]]+1,dp[i-1][j-2coins[i-1]]+2……)
        //dp[i][j-coins[i-1]]=min(dp[i-1][j-coins[i-1]],dp[i-1][j-2coins[i-1]]+1……)
        //dp[i][j]=min(dp[i-1][j],dp[i][j-coins[i-1]]+1)
        const int INF=0x3f3f3f3f;
        int n=coins.size();
        vector<int> dp(amount+1,INF);
        dp[0]=0;
        for(int i=1;i<=n;++i)
          for(int j=coins[i-1];j<=amount;++j)
            dp[j]=min(dp[j],dp[j-coins[i-1]]+1);
         return dp[amount]>=INF?-1:dp[amount];
    }
};

三、零钱兑换II

. - 力扣（LeetCode）

class Solution {
public:
    int change(int amount, vector<int>& coins) {
       //dp[i][j]表示从前i个硬币选，正好可以凑成总金额的硬币组合数
       //如果i不选 dp[i][j]+=dp[i-1][j]
       //如果i选1个 dp[i][j]+=dp[i-1][j-coins[i-1]]
       //dp[i][j]+=dp[i-1][j-coins[i-1]]+=dp[i-1][j-2coins[i-1]]……
       //dp[i][j]+=dp[i][j-coins[i-1]]
       int n=coins.size();
       //分析初始化 当j=0 都是一种选法  当i=0时 无论如何凑不出j 状态无效
       vector<vector<int>> dp(n+1,vector<int>(amount+1));
       dp[0][0]=1;
       for(int i=1;i<=n;++i)
         for(int j=0;j<=amount;++j) //不会越界，可以从0开始
         {
           dp[i][j]+=dp[i-1][j];
           if(j>=coins[i-1]) dp[i][j]+=dp[i][j-coins[i-1]];
         }
       return dp[n][amount];
    }
};

滚动数组做优化：

class Solution {
public:
    int change(int amount, vector<int>& coins) {
       //dp[i][j]表示从前i个硬币选，正好可以凑成总金额的硬币组合数
       //如果i不选 dp[i][j]+=dp[i-1][j]
       //如果i选1个 dp[i][j]+=dp[i-1][j-coins[i-1]]
       //dp[i][j]+=dp[i-1][j-coins[i-1]]+=dp[i-1][j-2coins[i-1]]……
       //dp[i][j]+=dp[i][j-coins[i-1]]
       int n=coins.size();
       //分析初始化 当j=0 都是一种选法  当i=0时 无论如何凑不出j 状态无效
      vector<int> dp(amount+1);
       dp[0]=1;
       for(int i=1;i<=n;++i)
         for(int j=coins[i-1];j<=amount;++j) //不会越界，可以从0开始
           dp[j]+=dp[j-coins[i-1]]; //+= 0不会影响填表
       return dp[amount];
    }
};

四、完全平方数

. - 力扣（LeetCode）

class Solution {
public:
//不能用贪心策略 比如说1 4 9   组成12    444比9111好
    int numSquares(int n) {
      //1 4 9 16 25……
      //dp[i][j]表示从前i个数选，刚好为j的最少数量
      const int INF=0x3f3f3f3f;
      int m=sqrt(n);
      vector<int> dp(n+1,INF);
      //i=0的时候 不可能凑成j  j=0时 i取1
      dp[0]=0;
    for(int i=1;i<=m;++i)
      for(int j=i*i;j<=n;++j)
         dp[j]=min(dp[j],dp[j-i*i]+1);
      return dp[n]; //一定能选得到，因为1是平方数 所以必然能凑出来
    }
};

五、数位成本和为目标值的最大数字（经典dp还原）

. - 力扣（LeetCode）

class Solution {
public:
    string largestNumber(vector<int>& nums, int t) {
      //考虑数值长度问题，每个数字有相应成本，且长度均为1 
      //有若干物品，求给定费用下所能选择的最大价值  （完全背包）
      //得到的就是最大位数 然后从后往前想办法还原回来
      vector<int> dp(t+1,-0x3f3f3f3f);//会有不存在的状态
      //dp[i][j]表示前i个数选择 正好为j的最大选择数目
      dp[0]=1;
      for(int i=1;i<=9;++i)
        for(int j=nums[i-1];j<=t;++j)
          dp[j]=max(dp[j],dp[j-nums[i-1]]+1);
          //此时 dp[t]里存的就是选择的最大位数 然后要想办法进行还原
          if(dp[t]<0) return "0";
          string ret;
          //开始还原 从后往前还原
          for(int i=9;i>=1;--i)
          {
             int u=nums[i-1];
             while(t>=u&&dp[t]==dp[t-u]+1)//说明选到这个数了
               {
                ret+=to_string(i);
                t-=u;
               }
          }
        return ret;
    }
};

六、获得分数的方法数（多重背包）

. - 力扣（LeetCode）

 该种类型题的具体分析请看第7题！！

class Solution {
public:
    const int MOD=1e9+7;
    int waysToReachTarget(int target, vector<vector<int>>& types) {
        //dp[i][j]表示从前i个数选 恰好分数为j的方案数 选择方式是types[1] 
        //如果不选这个数 dp[i-1][j]
        //如果选 1个  dp[i-1][j-p[0]] 
        //如果选2个  dp[i-1][j-2p[0]]
        int n=types.size();
        vector<vector<int>> dp(n+1,vector<int>(target+1));
        //初始化当i为0时 
        dp[0][0]=1;
        for(int i=1;i<=n;++i)
        {
            int count=types[i-1][0],mark=types[i-1][1]; //count表示这道题的题数（选择次数）  mark表示这道题的分数
            for(int j=0;j<=target;++j)
            {
                dp[i][j]=dp[i-1][j];
                for(int k=1;k<=count;++k)
                {
                    if(j>=k*mark) dp[i][j]=(dp[i][j]+dp[i-1][j-k*mark])%MOD;
                }
            }
        }
        return dp[n][target];
    }
};

滚动数组优化 

class Solution {
public:
    const int MOD=1e9+7;
    int waysToReachTarget(int target, vector<vector<int>>& types) {
        //dp[i][j]表示从前i个数选 恰好分数为j的方案数 选择方式是types[1] 
        //如果不选这个数 dp[i-1][j]
        //如果选 1个  dp[i-1][j-p[0]] 
        //如果选2个  dp[i-1][j-2p[0]]
        vector<int> dp(target+1);
        //初始化当i为0时 
        dp[0]=1;
        for(auto&p:types)
        {
            int count=p[0],mark=p[1]; //count表示这道题的题数（选择次数）  mark表示这道题的分数       //会用到上一层的状态，所以滚动数组应该要从后往前
            for(int j=target;j>=0;--j)
            {
                count=min(count,j/mark);
                for(int k=1;k<=count;++k)
                   dp[j]=(dp[j]+dp[j-k*mark])%MOD;
            }
        }
        return dp[target];
    }
};

进阶优化：

class Solution {
public:
    const int MOD=1e9+7;
    int waysToReachTarget(int target, vector<vector<int>>& types) {
        //dp[i][j]表示从前i个数选 恰好分数为j的方案数 选择方式是types[1] 
        //如果不选这个数 dp[i-1][j]
        //如果选 1个  dp[i-1][j-p[0]] 
        //如果选2个  dp[i-1][j-2p[0]]
        //dp[i][j]+=dp[i-1][j-p[0]]……
        //dp[i][j-p[0]+=dp[i-1]][j-]
        vector<int> dp(target+1);
        //初始化当i为0时 
        dp[0]=1;
        for(auto&p:types)
        {
            int count=p[0],mark=p[1]; //count表示这道题的题数（选择次数）  mark表示这道题的分数       //会用到上一层的状态，所以滚动数组应该要从后往前
            for(int j=mark;j<=target;++j)
            dp[j]=(dp[j]+dp[j-mark])%MOD;
            for(int j=target;j>=(count+1)*mark;--j)
            dp[j] = (dp[j] - dp[j - mark*(count + 1)] + MOD) % MOD; // 两个同余前缀和的差
            //防止搞出负数
        }
        return dp[target];
    }
};

七、带和限制的子多重集合的数目（经典多重背包模版题）

. - 力扣（LeetCode）

 直接做滚动数组优化：

class Solution {
public:
      const int MOD=1e9+7;
    int countSubMultisets(vector<int>& nums, int l, int r) {
        //01背包 每个数选或者不选 限制范围是l-r
        //dp[i][j]表示从前i个数选  凑成和恰好为j
        //但是需要一个哈希表来帮助我们知道每个数究竟可以选多少次
        unordered_map<int,int> hash;
        int total=0;
        for(auto&e:nums) 
        {
              total+=e;
              ++hash[e];
        }
        if(l>total) return 0;
        r=min(r,total);
        vector<int> dp(r+1);
        //初始化 i=0时 无数可选
        dp[0]=hash[0]+1;
        hash.erase(0);
        int t=0;
        for(auto[x,c]:hash) //x是数 c是他的限制次数
          for(int j=r;j>=x;--j)
           {
               c=min(c,j/x);
             for(int k=1;k<=c;++k)    //费时间 想办法用新的状态
                 dp[j]=(dp[j]+dp[j-k*x])%MOD; 
           }
         int sum=0;
         for(int j=l;j<=r;++j)
            sum=(sum+dp[j])%MOD;
            return sum;
    }
};

我们会发现由于数据量太大，用循环会超时，因此我们在这里不能用k那一层循环！！得换个方式

class Solution {
public:
      const int MOD=1e9+7;
    int countSubMultisets(vector<int>& nums, int l, int r) {
        //01背包 每个数选或者不选 限制范围是l-r
        //dp[i][j]表示从前i个数选  凑成和恰好为j
        //但是需要一个哈希表来帮助我们知道每个数究竟可以选多少次
        //类比完全背包的状态 dp[]
        unordered_map<int,int> hash;
        int total=0;
        for(auto&e:nums) 
        {
              total+=e;
              ++hash[e];
        }
        if(l>total) return 0;
        r=min(r,total);
        vector<int> dp(r+1);
        dp[0]=hash[0]+1;
        hash.erase(0);
        // dp[i][j]+=  dp[i-1][j-x]+dp[i-1][j-2*x]……
        // dp[i][j-x]+=dp[i-1][j-2x]+dp[i-1][j-3x]……
        int sum=0;
        for(auto[x,c]:hash)
        {
             sum = min(sum+x*c,r);//目前为止 能选的元素和之多为sum 
            for (int j = x; j <= sum; j++)
                dp[j] = (dp[j] + dp[j - x]) % MOD; // 原地计算同余前缀和
             for (int j =sum;j >= x * (c + 1); j--)
                dp[j] = (dp[j] - dp[j - x * (c + 1)] + MOD) % MOD; // 两个同余前缀和的差
                //防止搞出负数
        }
        
         int ret=0;
         for(int j=l;j<=r;++j)
            ret=(ret+dp[j])%MOD;
            return ret;
    }
};

 

✿༺小陈在拼命༻✿
关注
  • 112
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 97
    评论
专栏目录
背包问题介绍背包问题.zip
03-21
2. **完全背包问题**：每个物品可以无限数量地放入背包，只要不超过背包容量。 3. **多重背包问题**：每个物品有有限的数量，可以选择多次，但总数不能超过限制。 4. **部分背包问题**：物品可以被分割成任意小的...
DP-:软件工程作业之背包问题
03-30
此外，背包问题还有多种变体，如多重背包、完全背包等，它们在解决策略上会有细微差别，但核心的DP思想是一致的。 总结，软件工程中的背包问题通过动态规划方法，利用状态转移方程和记忆化搜索，能够有效地求解物品...
01背包问题 图解+详细解析(2022.02.10).pdf
02-10
01背包问题 图解+详细解析(2022.02.10).pdf
背包问题——01背包|完全背包
冷兮雪的博客
04-21 2万+
01背包你真的都会吗?各位佬们还不进来看看？
动态规划——01背包问题
Wu_L7的博客
04-22 3万+
面向小白的动态规划之01背包问题的详细讲解
01背包问题（通俗易懂，图例讲解）
AgonyAngela的博客
03-10 5307
01背包问题
动态规划——0/1背包问题(全网最细+图文解析)
Biteht的博客
05-08 6万+
01背包你真的掌握了吗?进来带你10分钟秒杀
动态规划背包问题之01背包详解
晨的博客
07-16 4万+
动态规划背包问题之01背包详解
什么是背包问题，用python解决背包问题
03-21
这个问题可以分为多个子类，如完全背包问题、0-1背包问题、多重背包问题等。 **0-1背包问题** 0-1背包问题是最基础的背包问题类型，其中每个物品都有一个固定的价值和重量，且每种物品只能选择放一个或者不放，不...
背包问题九讲html版本
最新发布
03-25
3. **多重背包问题**：每个物品有有限的数量，可以多次选取，但总量有限制。 4. **部分背包问题**：物品可以被分割成任意大小放入背包，只要总重量不超过背包容量。 **解冑方法** 1. **动态规划**：这是解决背包...
动态规划之0-1背包问题（详解+分析+原码）
未见花闻的博客
05-08 4万+
本篇文章将介绍算法专题之动态规划中的背包问题，更准确的说是背包问题中最简单的一种类型，即0-1背包问题，就是给你一定容量的背包和若干物品，每种物品只能选一次，告诉你每件物品的价值和体积，求背包里面物品的最大总价值。
0-1背包的四种解法
星辰的博客
11-27 1万+
有句老话说得好，学会了0-1背包就学会了算法。本篇博客就来盘点一下0-1背包的4中常见解法。 动态规划法 既然要用动态规划法解0-1背包问题，就要能满足动态规划的两个特性： 具有重叠子问题。 具有最优子结构性。 这两点应该很容易就可以看出，这里就不做过多赘述了。 直接来看关键，之前说过，动态规划的本质就是填表，而解动态规划问题的关键是找出动态转移方程，一旦找出动态转移方程，就可以用方程把整个表都填满了。 这里直接给出动态转移方程 V(i, j)表示在前i(1≤i≤n)个物品中能够装入容量为j（1≤j≤C
动态规划：01背包问题
热门推荐
qq_42174306的博客
03-16 7万+
一、什么是01背包问题？ 举个例子，你要去一个水果摊拿水果，每种水果都有对应的两种属性：占用的体积V和蕴含的价值W。而你的背包体积为N。老板说：每种水果只能拿一个！因此对于咱们肯定得想一种搭配方式使得拿的水果总体积不超过背包容积，但是价值总和达到最大！ 核心思想： f[i][j]:表示所有选法集合中,只从前i个物品中选,并且总体积不大于j的选法的集合,它的值是这个集合中每一个选法的最大值。 对于01背包问题选择方法的集合可以分成2种：...
【动态规划算法】背包问题——0/1背包问题，多目标优化背包问题详解与示例
qq_35831906的博客
11-13 1万+
背包问题是动态规划中的一个经典问题，通常有两种主要变种：0/1 背包问题和背包问题（Fractional Knapsack Problem）。这里我们先详细解释0/1背包问题再介绍背包问题的变种。
01背包问题的多种求解
m0_64862358的博客
12-30 4726
关于01背包问题的多种解法
【背包问题详解】【01背包问题】【完全背包问题】【多重背包问题—暴力解法/二进制优化】
不再痛苦的秘密，你找到了吗
03-29 2256
01背包（滚动数组优化）（优化到一维数组），完全背包，多重背包（暴力算法）（二进制优化算法）
九种 0-1 背包问题详解
Tyler_Zx的博客
08-10 1万+
目录 动态规划概念 问题1：0-1背包问题 问题2：完全背包问题 问题3：多重背包问题 问题4：混合背包问题 问题5：二维背包问题 问题6：分组背包问题 问题7：有依赖的背包问题(困难) 问题8：背包问题求方案数 问题9：背包问题求具体方案 前言 0-1 背包是一个经典的问题，之前也整理过一篇关于　0-1 背包的博客，当时只是整理了　0-1 背包问题的4 种解决方法。最近在复习算法，发现有很多　0-1 背包问题的衍生问题。0-1 背包问题的限制条件既可以是重量，也可以是容量，或者..
【动态规划】01背包问题（手画图解）
这个人很勤快，但还是什么也没有。
02-07 6178
01背包问题是所有背包问题的根本所在，掌握好dp五部曲，明确dp及其下标含义，勤加练习是制胜之道！
DD神牛深度解析：2013背包问题九讲
文章探讨了不同类型的背包问题混合的情况，如01背包、完全背包和多重背包的组合，以及如何分别处理这些问题。 5. 二维费用的背包问题： 物品不仅有价值，还有成本，涉及如何在满足费用限制的同时最大化收益。这里...
评论 97
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

✿༺小陈在拼命༻✿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值