动态规划之背包问题(01背包问题、完全背包问题、方案数填满型背包问题)

简介: 动态规划之背包问题(01背包问题、完全背包问题、方案数填满型背包问题)

目录

那年深夏        

引入

动态规划是什么?

2.什么是背包问题?

3.背包问题的使用价值

01背包

题目

用纯暴力思想分析

动态规划思想来做

二维版

一维优化版

变式

读题

分析

代码实现

完全背包

题目

分析

方案数填满型背包

方案数填满型01背包

题目

分析

代码

方案数填满型完全背包

题目

代码

最后


那年深夏        

        从晚霞漫天到黑暗阴森,只是一瞬。一阵晚风吹来,传来乌鸦沙哑的嘶鸣,将似暗未暗的荒野衬得更加寂寥了。

       夜色降临,惨淡的月光洒满大地,荒寂的草丛在清冷月光的照耀下,生出无数诡秘暗影。小坟,单铲,一人。空灵中,乌鸦落地,一对皮靴,踏着稀草走来,一支手枪在残星中,若隐若现。

       急促的喘息,伴着无限的悔恨,在飞快地装着物品。一件件珍物,从亡灵手中夺去,又经过精密的计算,动态规划算法的处理,装进背包。

       站起,提包,正去。“乌——”乌鸦嘶叫一声,一颗子弹划破夜空……


引入

       上面的东西,目的在于骗取吸引读者,并回应某些人。同时,也起到了引出下文、暗示中心的目的。

       没错,从标黑字体可以看出,今天我们要讲的是:背包问题。而且,我们用的是动态规划的算法。

动态规划是什么?

动态规划(英语:Dynamic programming,简称 DP),是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的,通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。

百度的还是那么严谨枯燥,简单来说,动态规划即:

通过将问题拆分成一个一个小问题,记录过往结果,减少重复运算。

举个栗子:

A : "1+1+1+1+1+1+1+1 =?"

A : "上面等式的值是多少"

B : 计算 "8"

A : 在上面等式的左边写上 "1+" 呢?

A : "此时等式的值为多少"

B : 很快得出答案 "9"

A : "你怎么这么快就知道答案了"

A : "只要在8的基础上加1就行了"

A : "所以你不用重新计算,因为你记住了第一个等式的值为8!动态规划算法也可以说是 '记住求过的解来节省时间'"


感谢🙇‍

@四舍五入两米高的小晨

2.什么是背包问题?

背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为:给定一组物品,每种物品都有自己的重量和价格,在限定的总重量内,我们如何选择,才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学,计算复杂性理论、密码学和应用数学等领域中。也可以将背包问题描述为决定性问题,即在总重量不超过W的前提下,总价值是否能达到V?它是在1978年由Merkle和Hellman提出的。

常见分类:

01背包

完全背包

多重背包

分组背包

今天我们将讲解前两种——01背包和完全背包,以及方案数填满型背包。

3.背包问题的使用价值

背包问题在现实中也有着广泛的应用,很多实际问题都可以被抽象为背包问题,比如股市投资、国家预算、资源分配,工业生产和运输,军事等。


01背包

题目

最基本的背包问题就是01背包问题(01 knapsack problem):一共有N件物品,第i(i从1开始)件物品的重量为w[i],价值为v[i]。在总重量不超过背包承载上限W的情况下,能够装入背包的最大价值是多少?

用纯暴力思想分析

既然有东西、有重量,那么我们可以选择装或不装,用递归即可实现。

有趣,提到了装或不装这个概念,我们就在这点上找找,看下有什么发现。

动态规划思想来做

二维版

我们的目标是书包内物品的总价值,而变量是物品和书包的限重(表示为w),所以我们可定义状态dp:

dp[i][j]表示将前i件物品装进限重为j的背包可以获得的最大价值, 0<=i<=N, 0<=j<=W

那么我们可以将dp[0][0...总重]初始化为0,表示将前0个物品(即没有物品)装入书包的最大价值为0。那么当 i > 0 时dp[i][j]有两种情况:

1.不装入第i件物品,即dp[i−1][j]

2.装入第i件物品(前提是能装下),即f[i−1][j−w[i]] + v[i]

因为情况2有个能装下的前提,因此需要if语句

因为需要的是最大价值,因此用max()函数取大,则可列出如下代码:

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

image.gif

一维优化版

经过观察可以发现,f[i][j]需要的只与其上与其左有关,那么我们就可以进行优化.

先把上述冗余的i删掉,然后把if语句提到for循环里(需要一个简单的逻辑,这里就不讲了)

不过,要倒叙来进行操作。因为与其左边也有关联;如果是正序,用到的是f[i][j-w[i]],而非f[i-1][j-w[i]+v[i]。这就错了。

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

image.gif

变式

读题

【背包练习】金明的预算方案

【题意】

金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是,妈妈昨天对他说:“你的房间需要购买哪些物品,怎么布置,你说了算,只要不超过N元钱就行”。今天一早,金明就开始做预算了,他把想买的物品分为两类:主件与附件,附件是从属于某个主件的,下表就是一些主件与附件的例子:

主件

附件

电脑

打印机,扫描仪

书柜

图书

书桌

台灯,文具

工作椅

如果要买归类为附件的物品,必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。

金明想买的东西很多,肯定会超过妈妈限定的N元。于是,他把每件物品规定了一个重要度,分为5等:用整数1~5表示,第5等最重要。他还从因特网上查到了每件物品的价格(都是10元的整数倍)。他希望在不超过N元(可以等于N元)的前提下,使每件物品的价格与重要度的乘积的总和最大。

设第j件物品的价格为v[j],重要度为w[j],共选中了k件物品,编号依次为j1,j2,……,jk,则所求的总和为:v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。(其中*为乘号)

请你帮助金明设计一个满足要求的购物单。

【输入格式】

第1行为两个正整数N、m,N表示总钱数,m为希望购买物品的个数(N<32000,m<60)。

下来m行,每行给出了编号为i的物品的基本数据,每行有3个非负整数v、p、q(其中v表示该物品的价格(v<10000),p表示该物品的重要度(1~5),q表示该物品是主件还是附件。如果q=0,表示该物品为主件,如果q>0,表示该物品为附件,q是所属主件的编号)。

【输出格式】

只有一个正整数,为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<200000)。

【样例输入】

1000 5

800 2 0

400 5 1

300 5 1

400 3 0

500 2 0

【样例输出】

2200

分析

很显然,这就是在01背包的基础上,增加了主件与附件。而且附件不超过2件。在输入时将主副件捆绑在一起。

那么,就有5种操作

1.什么都不取

2.只取主件

3.取主件又取1号附件

4.取主件又取2号附件

5.取主件且取1、2号附件

代码实现

#include<bits/stdc++.h>
using namespace std;
int n,m,w[66][3],v[66][3],f[56666];
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=n;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        if(z==0)
        {
            w[i][0]=x;
            v[i][0]=x*y;
        }
        else
        {
            if(w[z][1])
            {
                w[z][2]=x;
                v[z][2]=x*y;
            }
            else
            {
                w[z][1]=x;
                v[z][1]=x*y;
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(w[i][0])
        {
            for(int j=m;j>=w[i][0];j--)
            {
                f[j]=max(f[j],f[j-w[i][0]]+v[i][0]);
                if(w[i][1]&&j-w[i][0]>=w[i][1])
                {
                    f[j]=max(f[j],f[j-w[i][0]-w[i][1]]+v[i][0]+v[i][1]);
                }
                if(w[i][2]&&j-w[i][0]>=w[i][2])
                {
                    f[j]=max(f[j],f[j-w[i][0]-w[i][2]]+v[i][0]+v[i][2]);
                }
                if(w[i][2]&&j-w[i][0]>=w[i][1]+w[i][2])
                {
                    f[j]=max(f[j],f[j-w[i][0]-w[i][2]-w[i][1]]+v[i][0]+v[i][2]+v[i][1]);
                }
            }
        }
    }
    printf("%d",f[m]);
}

image.gif


完全背包

题目

小明背着一个背包(最大能带的重量为T)走进一个山洞,山洞里有n种 宝石(每种宝石无限多个),第 i 种 宝石的重量为ti,拿到宝石店能卖mi块钱。

求在背包能承受重量的范围内,使得小明装进背包的宝石总价值最大。

分析

完全背包与01背包不同就是每种物品可以有无限多个。

我们的目标和变量和01背包没有区别,所以我们可定义与01背包问题几乎完全相同的状态dp:

dp[i][j]表示将前i种物品装进限重为j的背包可以获得的最大价值, 0<=i<=N, 0<=j<=W

那么dp[i][j]也有两种情况:

1.不装入第i种物品,即dp[i][j]=dp[i-2][j];

2.装入第i种物品,此时和01背包不太一样,因为每种物品有无限个,所以此时不应该转移到dp[i−1][j−w[i]]而应该转变到dp[i][j−w[i]],即装入第i种商品后还可以再继续装入第种商品。

同样,我们也可以进行转化,变为一维。只需将01背包第二层循环的倒叙变为正序即可。因为此时计算f[j]时用到了 f[jj] (jj表示现在之前的j),而 f[jj] 已经有了第i颗宝石的影响,所以f[j]的计算用到了包含第i颗宝石影响的小规模状态,f[j]就相当于有多次第i颗宝石影响,相当于第i颗宝石可以取多次。

所以核心代码如下:

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

image.gif


方案数填满型背包

方案数填满型背包分为方案数填满型01背包方案数填满型完全背包

方案数填满型01背包

题目

【题意】

       有N (1 <= N <= 250)个数,每个数v_i (1 <= V_i <= 2,000),现在要分成两组,两组的和尽量接近,同时需要求出得到最接近和的方案数(mod 1,000,000)。

【输入格式】

       第一行N,下来N行,每行一个整数Vi。

【输出格式】

       第一行:最小差距。

       第二行:得到最小差距的方案数(mod 1000 000)

【样例输入】

5

2

1

8

4

16

【样例输出】

1

1

样例输入

分析

题目本身的问题就不多说,重点研究方案数。

设f[i][j]表示组合成j这个数的方案数。

那就用它本身,表示它本来的方案数,加上拿a[i]的方案数。(因为如果第i件物品放入背包,则背包容量还剩j-w[i],所以要取前i-1件物品放入背包剩余容量j-w[i]的方案数f[i-1][j-w[i]]。)

同理,转化为一维也要转化为倒叙,这里就不再罗嗦了。

代码

#include<bits/stdc++.h>
using namespace std;
int n,a[2005],f[9999990],sum;
int main()
{
    scanf("%d",&n);
    f[0]=1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        sum+=a[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=sum/2;j>=a[i];j--)
        {
            f[j]=(f[j]+f[j-a[i]])%1000000;
        }
    }
    for(int i=sum/2;i>=0;i--)
    {
        if(f[i]>0)
        {
            printf("%d\n",sum-i*2);
            printf("%d",f[i]);
            exit(0);
        }
    }
}

image.gif

方案数填满型完全背包

题目

【问题描述】

       有一道数学题, a1*x1+a2*x2+……+an*xn=c。

       已知c还有 a1、a2…an,求解x1到xn有多少组解?

【输入】

       第一行是n和c。

       第二行n个数分别是a1到an。 (保证a1~an,x1~xn,c均为正整数)

【输出】

       一个整数,代表总解数(用999983模)。

【样例输入】

2 4

1 2

【样例输出】

3

【限制】

       30%的数据满足:n<=10,c<=100

       100%的数据满足:n<=100,c<=100000

废话不说,上代码。仅仅就改了一下第二层循环的顺序(具体看上面的完全背包->分析)

代码

#include<bits/stdc++.h>
using namespace std;
int f[110000],a[110],n,c;
int main()
{
    f[0]=1;
    scanf("%d%d",&n,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=n;i++)
    {   
        for(int j=a[i];j<=c;j++)
        {
            f[j]=(f[j]+f[j-a[i]])%999983;
        } 
    }
    printf("%d",f[c]);
}

image.gif


最后

背包问题作为噩梦的开始,不是很考验思维,有比较固定的格式,被就(即)完(蛋)了

动态规划重在自己理解,因为许多东西是难以用言语表达出来的,看了别人的,反而可能会搞混。。。

相关文章
|
移动开发 算法 调度
【贪心算法】一文让你学会“贪心”(贪心算法详解及经典案例)
贪心算法是一种非常常见的算法,它的简单和高效性使其在实际应用中被广泛使用。 贪心算法的核心思想是在每一步都采取当前状态下最优的选择,而不考虑未来可能产生的影响。虽然贪心算法不能保证总是得到最优解,但在很多情况下,它可以获得很好的结果。 本篇文章将介绍贪心算法的基本概念和一些经典应用,以及如何通过贪心算法来解决一些实际问题。希望通过本文的阅读,读者可以对贪心算法有更加深刻的理解,并能够在实际问题中应用贪心算法来得到更好的解决方案。 让我们暴打贪心算法吧!
6829 0
|
数据采集 自然语言处理 搜索推荐
图文详解 DFS 和 BFS | 算法必看系列知识二十四
深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法,生产上广泛用于拓扑排序,寻路(走迷宫),搜索引擎,爬虫等,也频繁出现在高频面试题中。
37733 6
图文详解 DFS 和 BFS | 算法必看系列知识二十四
|
存储 算法 NoSQL
还分不清 Cookie、Session、Token、JWT?看这一篇就够了
Cookie、Session、Token 和 JWT(JSON Web Token)都是用于在网络应用中进行身份验证和状态管理的机制。虽然它们有一些相似之处,但在实际应用中有着不同的作用和特点,接下来就让我们一起看看吧,本文转载至http://juejin.im/post/5e055d9ef265da33997a42cc
50796 16
|
SQL 关系型数据库 数据库
学习分布式事务Seata看这一篇就够了,建议收藏
学习分布式事务Seata看这一篇就够了,建议收藏
24048 2
|
存储 自然语言处理 算法
【LeetCode 热题100】208:实现 Trie (前缀树)(详细解析)(Go语言版)
本文详细解析了力扣热题 208——实现 Trie(前缀树)。Trie 是一种高效的树形数据结构,用于存储和检索字符串集合。文章通过插入、查找和前缀匹配三个核心操作,结合 Go 语言实现代码,清晰展示了 Trie 的工作原理。时间复杂度为 O(m),空间复杂度也为 O(m),其中 m 为字符串长度。此外,还探讨了 Trie 的变种及应用场景,如自动补全和词典查找等。适合初学者深入了解 Trie 结构及其实际用途。
457 14
|
3月前
|
人工智能 自然语言处理 Java
Spring AI Alibaba实战:从0到1构建企业级智能应用
本文介绍了基于SpringAI Alibaba框架开发AI原生应用的实战指南。文章首先分析了SpringAI Alibaba作为SpringAI本土化版本的核心优势,包括深度适配阿里云生态、中文语境优化等特性。随后详细讲解了开发环境的搭建过程,包括JDK17、SpringBoot3.2.2等技术栈的配置。通过三个实战案例展示了核心功能实现:基础文本生成、结合MyBatisPlus的智能问答系统、以及流式响应和函数调用等高级特性。
3474 6
|
安全 Unix Linux
VMware Workstation 17.6.3 发布下载,现在完全免费无论个人还是商业用途
VMware Workstation 17.6.3 发布下载,现在完全免费无论个人还是商业用途
132675 65
|
SQL 算法 数据挖掘
动态规划Dynamic programming详解-编辑距离问题【python】
动态规划Dynamic programming详解-编辑距离问题【python】
|
存储 算法 Java
【DFS(深度优先搜索)详解】看这一篇就够啦
本文介绍了深度优先搜索(DFS)算法及其应用。DFS从某个顶点出发,深入探索图的每条路径,直到无法前进为止,然后回溯。文章详细解释了DFS的基本思想,并通过示例图展示了其执行过程。此外,文中还探讨了三种枚举方式:指数型枚举、排列型枚举和组合型枚举,并提供了具体的代码实现。最后,文章通过几道练习题帮助读者更好地理解和应用DFS算法。
10881 19
【DFS(深度优先搜索)详解】看这一篇就够啦

热门文章

最新文章

下一篇
开通oss服务