一篇解决背包问题

最新推荐文章于 2022-07-15 17:38:49 发布
最新推荐文章于 2022-07-15 17:38:49 发布
阅读量522 收藏 3
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 刷题 C语言 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53893431/article/details/123903722
本文详细介绍了0-1背包、完全背包和多重背包问题的动态规划解决方案，包括思路解析和代码实现。针对0-1背包，通过二维和一维动态规划优化算法，确保在有限的背包容量下获得最大价值。完全背包问题通过转换成多个0-1背包问题来解决，多重背包问题则分为两种思路，一是拆分再转化为0-1背包，二是利用二进制优化。所有代码示例都展示了如何高效地处理不同类型的背包问题。

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

文章目录


0-1背包问题

image-20220401135811676

思路1：二维动态规划法

对于状态f[i] [j]定义为前i给物品下，背包重量为j的最优解:

  • 当前的状态依赖于之前的状态，那么初始的状态f[0] [0]==0开始决策。有n个物品，则需要N种决策，每一次对第i件物品的决策，状态f[i] [j]不断由之前的状态跟新而来。

  • 对于第i件物品时，如果空间的容量不够， 那么f[i] [j]==f[i-1] [j]

  • 如果背包的容量够用，那么就有两种情况：

    • 如果选择了第i件物品，那么f[i] [j]==f[i-1] [j-v[i]]]+w[i]。

    • 如果没有选择第i件物品，那么 f[i] [j]==f[i-1] [j]

    • 那么最后的情况是两者的max()

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N][N];
int v[N],w[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    //传入数量和体积
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            //如果体积不够用
            if(j<v[i])
                f[i][j]=f[i-1][j];
            //如果体积够用
            else
            {
                f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
            }
        }
    }
    int res=0;
    for(int j=0;j<=m;j++) res=max(res,f[n][j]);
    cout<<res<<endl;
    return 0;
}

优化：一维将状态f[i] [j]优化为一维f[j]，定义为:N件物品，背包容量为j的最优解。

  • 枚举的顺序必须是从最大容量m开始

  • 在二维的情况下，状态f[i] [j]是由上一轮的i-1的状态得来的

  • 为什么一维情况下枚举背包容量需要逆序？在二维情况下，状态f[i] [j]是由上一轮i - 1的状态得来的，f[i] [j]与f[i - 1] [j]是独立的。而优化到一维后，如果我们还是正序，则有f[较小体积]更新到f[较大体积]，则有可能本应该用第i-1轮的状态却用的是第i轮的状态。

  • 例如，一维状态第i轮对体积为 33 的物品进行决策，则f[7]由f[4]更新而来，这里的f[4]正确应该是f [i - 1] [4]，但从小到大枚举j这里的f[4]在第i轮计算却变成了f[i] [4]。当逆序枚举背包容量j时，我们求f[7]同样由f[4]更新，但由于是逆序，这里的f[4]还没有在第i轮计算，所以此时实际计算的f[4]仍然是f[i - 1] [4]。

  • 简单来说，一维情况正序更新状态f[j]需要用到前面计算的状态已经被「污染」，逆序则不会有这样的问题。

    状态转移方程为：f[j] = max(f[j], f[j - v[i]] + w[i] 。

for(int i = 1; i <= n; i++) 
    for(int j = m; j >= 0; j--)
    {
        if(j < v[i]) 
            f[i][j] = f[i - 1][j];  // 优化前
            f[j] = f[j];            // 优化后，该行自动成立，可省略。
        else    
            f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);  //优化前
            f[j] = max(f[j], f[j - v[i]] + w[i]);                   // 优化后
    }    

for(int i=1;i<=n;i++)
{
    for(int j=m;j>=v[i];j--)
    {
        f[j]=max(f[j],f[j-v[i]]+w[i]);
    }
}

完整代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int v,w;
        cin>>v>>w;
        for(int j=m;j>=v;j--)
        {
            f[j]=max(f[j],f[j-v]+w);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

完全背包问题

image-20220401151347187

思路：把完全背吧问题转化为多个0-1背包问题

#include<iostream>
#include<cstring>
using namespace std;
const int N=1010;
int n,m;
int f[N][N];
int v[N],w[N];
int main()
{
    //传入物品的种类和和背包的容量
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;j>=k*v[i];k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

不出意外，该算法Time Limit Exceeded ，现在有的办法是对该算法进行将维处理。降低算法的循环次数。

  • f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w , f[i-1,j-2v]+2w , f[i-1,j-3v]+3w , …)
  • f[i , j-v]= max( f[i-1,j-v] , f[i-1,j-2v] + w , f[i-1,j-3v]+2*w , …)
    由上两式，可得出如下递推关系：
    f[i] [j]=max(f[i,j-v]+w , f[i-1] [j])
  • 对上面的代码进行改造
for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            if(j>=v[i])
            {
                f[i][j]=max(f[i][j-v]+w,f[i-1][j]);
            }
        }
	}

完整代码

include<iostream>
#include<cstring>
using namespace std;
const int N=1010;
int n,m;
int f[N][N];
int v[N],w[N];
int main()
{
    //传入物品的种类和和背包的容量
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            //如果没有足够的容量放入
            f[i][j]=f[i-1][j];
            if(j-v[i]>=0)
                f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

进一步优化

逆序是为了保证更新当前状态时，用到的状态是上一轮的状态，保证每个物品只有一次或零次;在这里，因为每个物品可以取任意多次，所以不再强求用上一轮的状态，即本轮放过的物品，在后面还可以再放;

思路模拟：

首先dp数组初始化全为0：给定物品种类有4种，包最大体积为5，数据来源于题目的输入
v[1] = 1, w[1] = 2
v[2] = 2, w[2] = 4
v[3] = 3, w[3] = 4
v[4] = 4, w[4] = 5

i = 1 时： j从v[1]到5
dp[1] = max(dp[1],dp[0]+w[1]) = w[1] = 2 (用了一件物品1）
dp[2] = max(dp[2],dp[1]+w[1]) = w[1] + w[1] = 4（用了两件物品1）
dp[3] = max(dp[3],dp[2]+w[1]) = w[1] + w[1] + w[1] = 6（用了三件物品1）
dp[4] = max(dp[4],dp[3]+w[1]) = w[1] + w[1] + w[1] + w[1] = 8（用了四件物品1）
dp[5] = max(dp[3],dp[2]+w[1]) = w[1] + w[1] + w[1] + w[1] + w[1] = 10（用了五件物品）

i = 2 时：j从v[2]到5
dp[2] = max(dp[2],dp[0]+w[2]) = w[1] + w[1] = w[2] = 4（用了两件物品1或者一件物品2）
dp[3] = max(dp[3],dp[1]+w[2]) = 3 * w[1] = w[1] + w[2] = 6（用了三件物品1，或者一件物品1和一件物品2）
dp[4] = max(dp[4],dp[2]+w[2]) = 4 * w[1] = dp[2] + w[2] = 8（用了四件物品1或者，两件物品1和一件物品2或两件物品2）
dp[5] = max(dp[5],dp[3]+w[2]) = 5 * w[1] = dp[3] + w[2] = 10（用了五件物品1或者，三件物品1和一件物品2或一件物品1和两件物品2）

i = 3时：j从v[3]到5
dp[3] = max(dp[3],dp[0]+w[3]) = dp[3] = 6 # 保持第二轮的状态
dp[4] = max(dp[4],dp[1]+w[3]) = dp[4] = 8 # 保持第二轮的状态
dp[5] = max(dp[5],dp[2]+w[3]) = dp[4] = 10 # 保持第二轮的状态

i = 4时：j从v[4]到5
dp[4] = max(dp[4],dp[0]+w[4]) = dp[4] = 10 # 保持第三轮的状态
dp[5] = max(dp[5],dp[1]+w[4]) = dp[5] = 10 # 保持第三轮的状态

#include<iostream>
#include<cstring>
using namespace std;
const int N=1010;
int n,m;
int f[N];
int v[N],w[N];
int main()
{
    //传入物品的种类和和背包的容量
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            //如果没有足够的容量放入
            f[j]=f[j];
            if(j-v[i]>=0)
                f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

多重背包问题一

image-20220401165420165

思路一：帮多重背包问题强行拆为0-1背包问题

#include<iostream>
#include<cstring>
using namespace std;
int n,m;
//分别保存体积和价值
int v[10010],w[10010],t=0;
int dp[10010];
int main()
{
    cin>>n>>m;
    while(n--)
    {
        int v,w,s;
        cin>>v>>w>>s;
        while(s--)
        {
            //拆开多重背包问题
            a[++t]=v;
            b[t]=w;
        }
    }
    //解决0-1背包问题
    for(int i=1;i<=t;i++)
    {
        for(int j=m;j>a[i];j--)
        {
            dp[j]=max(dp[j],dp[j-a[i]+b[i]]);
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

复杂度有点高，对代码进行优化

#include<iostream>
#include<cstring>
using namespace std;
int dp[1010],n,t,v,w,s;
int main()
{
    cin>>n>>t;
    while(n--)
    {
        cin>>v>>w>>s;
        for(int i=1;i<=s;i++)
        {
            for(int j=t;j>=w;j--)
            {
                dp[j]=max(dp[j],dp[j-w]+w);
            }
        }
    }
    cout<<dp[t]<<endl;
    return 0;
}

思路二

#include<iostream>
#include<cstring>
#include<algorithm>
const int N=110;
int n,m;
int f[N];
using namespace std;
int main()
{
   cin>>n>>m;
   for(int i=1;i<=n;i++)
   {
       int v,w,s;
       cin>>v>>w>>s;
       for(int j=m;j>=0;j--)
       {
           for(int k=1;k<=s&&k*v<=j;k++)
           {
                f[j]=max(f[j],f[j-k*v]+k*w);
           }
       }
   }
   cout <<f[m]<<endl;
   return 0;
}

多重背包问题二

image-20220401172222815

二进制优化：对于任何一个数s，最少有[logs]个数可以表示0~s的所有整数。

比如对于7，我们有3个数：1，2，4(2的0次方，2的1次方，2的平方)可以表示0~7所有的数。

0=0； 1=1；2=2；3=1+2；4=4；5=1+4；6=2+4；7=1+2+4；

再不如10，我们有[log2 10]=4个数能表示010所有的数；010=(0~7)+3；

所有数分别为:1,2,4,3;

0=0； 1=1；2=2；3=3；4=4；5=1+4；6=2+4；7=1+2+4；8=1+3+4;

9=2+3+4;10=1+2+4+3

对于这个题：

我们可以把多重背包问题按照二进制转换为N*[log2 k]个0-1背包问题

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2010;
int n,m;

int f[N];

struct good
{
    int v;
    int w;//分别表示体积和价格
};
int main()
{
    vector<good>goods;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        int v,w,s;
        cin>>v>>w>>s;
        //把多重背包问题按照二进制转换为多个0-1背包问题
        for(int k=1;k<=s;k*=2)
        {
            s-=k;
            goods.push_back({v*k,w*k});
        }
        if(s>0) goods.push_back({v*s,w*s});
    }
    for(auto good:goods)
        for(int j=m;j>=good.v;j--)
        {
            f[j]=max(f[j],f[j-good.v]+good.w);
        }
        
    cout<<f[m]<<endl;
    return 0;
    
}

动态规划解决01背包问题
weixin_45285954的博客
09-17 742
一、问题描述： 有n 个物品，它们有各自的重量和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 二、总体思路： 根据动态规划解题步骤（问题抽象化、建立模型、寻找约束条件、判断是否满足最优性原理、找大问题与小问题的递推关系式、填表、寻找解组成）找出01背包问题的最优解以及解组成，然后编写代码实现； 三、动态规划的原理及过程： eg：number＝4，capacity＝8 　　 ...
Java背包问题求解实例代码
08-29
Java背包问题求解实例代码 ...这篇文章提供了Java语言中求解背包问题的实例代码，包括01背包和完全背包两种类型，并使用动态规划来解决问题。这个算法的时间和空间复杂度均为O(N*V)，可以满足大多数实际应用需求。
用背包问题思路解决 322. Coin Change（完全背包）
weixin_38168918的博客
08-12 160
首先需要明白 0-1 背包问题中的放置表格，见 “玩转算法面试 从真题到思维全面提升算法思维” 9-5 节，本题思路类似表格纵向为：只考虑第 [0 …,… index] 种硬币（物品）表格横向为：需要兑换的金额（背包容量）为 j表格内容为：在横向和纵向的条件下，最少的硬币（物品）数即：通过表格列举出，当硬币种类为 [0 …,… index] 种，兑换金额为 j 时，最少的硬币数量 ...
关于背包问题的求解思路
小呼哥的博客
03-17 529
求解背包问题： 首先理清是0-1背包还是完全背包，确定for循环，然后写状态方程 完全背包 518 零钱兑换II 377 组合总和 139单词拆分 322零钱兑换 这三种属于完全背包问题。 对于377这种，属于有序放入，要求背包在外循环，物品在内循环，dp[i]+=dp[i-num]; 如果不是有序放入，物品作为外循环，背包采用正序的方式进行内循环。 完全背包 对于322，每个零钱都可以使用，而且是无序，求解的是最少零钱数。 对于518 ，每种零钱都可以使用，而且是无序。组合成target的不同组合。 .
01背包问题如何处理
weixin_30904593的博客
04-08 173
参考https://i.cnblogs.com/EditPosts.aspx?opt=1 转载于:https://www.cnblogs.com/Edword-ty/p/10670414.html
01背包问题解题思路
qq_38016957的博客
03-20 1568
F(i,j)表示取前i个物品，使他们总体积不超过j的最优取法取得的价值总和 寻找递推关系式，面对当前商品有两种可能性： 第一，包的容量比该商品体积小，装不下，此时的价值仍为上一个状态(i-1)的价值且当前容量不变，即F(i,j)=F(i-1,j); 第二，还有足够的容量可以装该商品，但装了也不一定达到当前最优价值，装了之后即F(i,j)=F(i-1 , j - w(i))+v(i);这里的j为上个...
Python基于贪心算法解决背包问题示例
09-21
本篇文章将详细介绍如何使用贪心算法解决完全背包问题。 #### 三、完全背包问题概述 完全背包问题是背包问题的一种，与0-1背包问题不同的是，在完全背包问题中，物品可以分割装入背包。给定n个物品和一个容量为C的...
动态规划背包问题6篇讲解+源码
最新发布
03-29
动态规划是解决背包问题的一种经典方法，它通过将原问题分解为子问题，并保存子问题的解来避免重复计算，从而优化算法的效率。背包问题通常涉及一系列物品，每个物品有各自的重量和价值，目标是在不超过背包总重量的...
一种求解背包问题的改进离散粒子群优化算法.pdf
09-29
【标题】: 一种求解背包问题的改进离散粒子群优化算法 【描述】: 该文介绍了一种改进的离散粒子群优化算法，该算法针对经典的背包问题进行了优化，通过重新定义粒子的速度和位置公式，适应离散问题的求解。 【标签...
【算法】【回溯篇】第7节：0-1背包问题
12-21
总的来说，0-1背包问题通过回溯法提供了一种有效解决组合优化问题的方法。通过深度优先搜索、剪枝策略以及状态记录，我们可以找到在给定限制下使总价值最大的物品组合。回溯法不仅适用于0-1背包问题，还可以应用于八...
背包问题解决方法总结
05-17
题目 有N件物品和一个容量为V的背包。第i件物品的重量是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 基本思路有好几种方法，请参考资源文件
01背包问题-四种方法
10-20
01背包问题,四种方法(动态规划、贪心、回溯、分支限界)
动态规划解决背包问题
weixin_30297281的博客
10-18 189
动态规划是什么 动态规划法的思想类似于分治法，基本思路就是把一个问题分解成若干个子问题。求解子问题，然后从子问题中得出原问题的解。因为用分治法解决问题，相同的子问题会被多次求解，所以如果将原来的解保存，就可以减少重复计算。这是我们为什么定义一个二维数组储存我们得到的结果的原因。 背包问题是什么 本文我们主要介...
背包问题的思路整理
weixin_41826641的博客
07-06 257
背包问题的思路整理 package algorithm; import java.util.Arrays; public class Backpack { public static void main(String[] args) { backpack(); } public static void backpack() { /* * 物品 1 2 3 4 * 价值 60 100 120 61 * 重量 1 2 3 1 */
来聊聊背包问题思路
zjscy666的博客
10-31 418
缘起 有童鞋反映背包问题太难了，看不懂，不理解精髓，希望小编能做个分享！郑重声明，具体的解法大家可以网上去看，本文主要讲解思路！ 背包问题定义和种类 先来看看官方定义：背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算复杂性理论、密码学和应用数学等领域中。也可以将背包问题描
完全背包问题的简化思路
二哈
11-22 897
1. 问题描述： 有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中价值总和的最大值 1≤n≤100 1≤wi，vi≤100 1≤W≤10000 输入： 第一行是n 第二行到是物品的重量 第三行是物品对应的价值 而且物品的数量是无限的，可以无限拿取 2. 我们之前动态规划的一般思路来解决这个问题，采用的策略是对于当前的物品我可以拿...
背包问题，动态规划，1 0背包，思路详解 带例题优化
kumoue的博客
07-15 291
例题：P1048 动态规划0、1背包思路详解.
背包问题（普通、完全、多重）的思路分析和代码模板
weixin_62493303的博客
05-19 510
背包问题作为一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。 我认为其具有比较固定的代码格式，故而将关注的重点放在状态转移方程上，便可以熟记求解过程，本文主要对其代码格式进行了分析和总结。
背包问题
MONKEY_Quan的博客
09-13 254
背包问题解决： 代码： public class KnapsackProblem { public static void main(String[] args) { int []w={1,4,3};//物品的重量 int []val={1500,3000,2000};//物品的价值 这里的val[i],就是前面的v[i] ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

影中人lx

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

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

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

打赏作者

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

抵扣说明：

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

余额充值