一篇解决背包问题

最新推荐文章于 2022-07-15 17:38:49 发布
最新推荐文章于 2022-07-15 17:38:49 发布
阅读量486 收藏 3
点赞数 3
分类专栏： 刷题 C语言 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53893431/article/details/123903722
版权

文章目录


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;
    
}

影中人lx
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
动态规划解决01背包问题
weixin_45285954的博客
09-17 697
一、问题描述： 有n 个物品，它们有各自的重量和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 二、总体思路： 根据动态规划解题步骤（问题抽象化、建立模型、寻找约束条件、判断是否满足最优性原理、找大问题与小问题的递推关系式、填表、寻找解组成）找出01背包问题的最优解以及解组成，然后编写代码实现； 三、动态规划的原理及过程： eg：number＝4，capacity＝8 　　 ...
Java背包问题求解实例代码
08-29
Java背包问题求解实例代码 ...这篇文章提供了Java语言中求解背包问题的实例代码，包括01背包和完全背包两种类型，并使用动态规划来解决问题。这个算法的时间和空间复杂度均为O(N*V)，可以满足大多数实际应用需求。
用背包问题思路解决 322. Coin Change（完全背包）
weixin_38168918的博客
08-12 125
首先需要明白 0-1 背包问题中的放置表格，见 “玩转算法面试 从真题到思维全面提升算法思维” 9-5 节，本题思路类似表格纵向为：只考虑第 [0 …,… index] 种硬币（物品）表格横向为：需要兑换的金额（背包容量）为 j表格内容为：在横向和纵向的条件下，最少的硬币（物品）数即：通过表格列举出，当硬币种类为 [0 …,… index] 种，兑换金额为 j 时，最少的硬币数量 ...
关于背包问题的求解思路
小呼哥的博客
03-17 425
求解背包问题： 首先理清是0-1背包还是完全背包，确定for循环，然后写状态方程 完全背包 518 零钱兑换II 377 组合总和 139单词拆分 322零钱兑换 这三种属于完全背包问题。 对于377这种，属于有序放入，要求背包在外循环，物品在内循环，dp[i]+=dp[i-num]; 如果不是有序放入，物品作为外循环，背包采用正序的方式进行内循环。 完全背包 对于322，每个零钱都可以使用，而且是无序，求解的是最少零钱数。 对于518 ，每种零钱都可以使用，而且是无序。组合成target的不同组合。 .
01背包问题如何处理
weixin_30904593的博客
04-08 141
参考https://i.cnblogs.com/EditPosts.aspx?opt=1 转载于:https://www.cnblogs.com/Edword-ty/p/10670414.html
01背包问题解题思路
qq_38016957的博客
03-20 1507
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 141
动态规划是什么 动态规划法的思想类似于分治法，基本思路就是把一个问题分解成若干个子问题。求解子问题，然后从子问题中得出原问题的解。因为用分治法解决问题，相同的子问题会被多次求解，所以如果将原来的解保存，就可以减少重复计算。这是我们为什么定义一个二维数组储存我们得到的结果的原因。 背包问题是什么 本文我们主要介...
背包问题的思路整理
weixin_41826641的博客
07-06 222
背包问题的思路整理 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 354
缘起 有童鞋反映背包问题太难了，看不懂，不理解精髓，希望小编能做个分享！郑重声明，具体的解法大家可以网上去看，本文主要讲解思路！ 背包问题定义和种类 先来看看官方定义：背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算复杂性理论、密码学和应用数学等领域中。也可以将背包问题描
完全背包问题的简化思路
二哈
11-22 854
1. 问题描述： 有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中价值总和的最大值 1≤n≤100 1≤wi，vi≤100 1≤W≤10000 输入： 第一行是n 第二行到是物品的重量 第三行是物品对应的价值 而且物品的数量是无限的，可以无限拿取 2. 我们之前动态规划的一般思路来解决这个问题，采用的策略是对于当前的物品我可以拿...
背包问题，动态规划，1 0背包，思路详解 带例题优化
kumoue的博客
07-15 244
例题：P1048 动态规划0、1背包思路详解.
背包问题（普通、完全、多重）的思路分析和代码模板
weixin_62493303的博客
05-19 460
背包问题作为一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。 我认为其具有比较固定的代码格式，故而将关注的重点放在状态转移方程上，便可以熟记求解过程，本文主要对其代码格式进行了分析和总结。
背包问题
MONKEY_Quan的博客
09-13 210
背包问题解决： 代码： 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、付费专栏及课程。

余额充值