【动态规划】背包问题详解

最新推荐文章于 2024-06-02 18:51:22 发布
最新推荐文章于 2024-06-02 18:51:22 发布
阅读量1.1k 收藏 9
点赞数 2
分类专栏： 基础算法与基础数据结构 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73176808/article/details/131928256
版权

动态规划（Dynamic Pogramming，简称dp）是运筹学的一个分支，是求解决策过程最优化的数学方法。背包问题则是dp问题里很常见的一类。本篇文章来详解一下背包问题。

目录

1、基础知识

动态规划的理解方式有很多种，这里讲述的是yxc老师的闫氏dp法，个人认为是最好的理解方式并且非常好用。
在这里插入图片描述
遇到dp问题，首先考虑状态表示，即如何（用什么、怎么样）把一个状态表示出来，区分两个不同状态的指标数量叫维度，我们要把相同的状态放入一个集合里面去，并且规定这个集合的属性（可能是最大值、最小值、元素数量等）。在此之后，我们要考虑状态计算，即如何把当前状态的集合计算出来。在这一步，我们一般采用划分集合的方式，即将一个大的集合划分为很多小的集合，这些小的集合可以计算出来，那么大的集合也就能计算出来了。一般要求是：划分集合时不重不漏。

听起来很抽象，确实是这样。dp问题需要不断做题积累经验，才能真正体会到其中的精髓。下面用背包问题来走一遍这个流程，方便理解。

背包问题是动态规划问题里的一种很常见题型，具体来说就是，给一个容量确定的背包，给一些体积确定、价值确定的物品，问怎样带才能带走价值最大的物品。好比说打游戏时，打怪掉落了很多物资，但是背包有限，就要想想带走什么才对自己最有用。我们用闫氏dp法来走一遍流程。

首先，考虑如何表示一个背包的状态：1.背包容量；2.放哪些物品。因此，背包问题集合的维度是二维的。具体表示方法不同的题目不同。因为问题需要，所以集合的属性自然就是价值的最大值。
然后就要考虑状态的计算了，即如何计算 f ( i , j ) f(i,j) f(i,j)的值。这个过程我们采取划分集合的方式，不同的题目有不同的考虑方式，下面用一些例题来实战。

2、01背包

01背包具体是：一个物品只有选（1）或不选（0）两种状态，固称为01背包。首先看一下例题 acwing 01背包

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。第 i 件物品体积是 v i v_i vi​，价值是 w i w_i wi​。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 v i v_i vi​, w i w_i wi​，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0< v i v_i vi​, w i w_i wi​≤1000
输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

我们可以用 f ( i , j ) f(i,j) f(i,j)来表示：只在前 i i i个物品里面选，且背包容量为 j j j。

划分集合时可以将只在前 i i i个物品里选划分为两个小集合：

  1. 所有选了 i i i的选法： f ( i − 1 , j − v i ) + w i f(i-1,j-v_i)+w_i f(i−1,j−vi​)+wi​；
  2. 所有不选 i i i的选法： f ( i − 1 , j ) f(i-1,j) f(i−1,j)。

这样就能不重不漏的把 f ( i , j ) f(i,j) f(i,j)分为两个小的集合了。同时由于 f ( i , j ) f(i,j) f(i,j)的属性是最大值，那么就可以表示为：
f ( i , j ) = m a x ( f ( i − 1 , j − v i ) + w i , f ( i − 1 , j ) ) f(i,j)=max(f(i-1,j-v_i)+w_i, f(i-1,j)) f(i,j)=max(f(i−1,j−vi​)+wi​,f(i−1,j))
这样就得到了dp问题最重要的状态计算方程。

得到了这个，这个题就可以直接做出来了：

#include <iostream>

using namespace std;

const int N = 1010;

int f[N][N];
int v[N], w[N];
int n, m;

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];

	//因为i等于0的时候f(i,j)一定是0（选0个物品），所以直接从1开始
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
        {
            f[i][j] = f[i - 1][j];
            //只有装得下物品i时，才考虑选了i的选法
            if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }

    cout << f[n][m];

    return 0;
}

dp问题就是这样神奇，看似很难，其实只要得到状态计算方程，很简洁的代码就能通过。

接下来，还能对代码进行优化。注意到 f ( i , j ) = m a x ( f ( i − 1 , j − v i ) + w i , f ( i − 1 , j ) ) f(i,j)=max(f(i-1,j-v_i)+w_i, f(i-1,j)) f(i,j)=max(f(i−1,j−vi​)+wi​,f(i−1,j))，每个 i i i状态都是由 i − 1 i-1 i−1状态得到的，因此可以用滚动数组的方式来更新。意思是：一个二维数组，每行都是由上一行得到的，那么就可以优化为一个一维数组，每次用新的值覆盖当前值，也即相当于由上一行得到下一行。那么核心部分代码：

f[i][j] = f[i - 1][j];

就可以优化为：

f[j] = f[j];

恒等式可以省略；其次第二个核心代码：

if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);

可以优化为：

if (j >= v[i]) f[j] = max(f[j], f[j - v[i]] + w[i]);

而由于循环是递增的，所以直接从v[i]开始即可：

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

但是这里有一个问题：注意到 f [ j − v [ i ] ] f[j-v[i]] f[j−v[i]]一定小于 f [ j ] f[j] f[j]，所以它一定会在 f [ j ] f[j] f[j]之前更新，那么更新 f [ j ] f[j] f[j]时，就相当于用本层的 f [ j − v [ i ] ] f[j-v[i]] f[j−v[i]]来更新，但计算公式要求用上一层的 f [ j − v [ i ] ] f[j-v[i]] f[j−v[i]]来更新，为解决这个问题，只需要把第二层循环逆向进行即可。这样能保证更新 f [ j ] f[j] f[j]时用到的是上一层的 f [ j − v [ i ] ] f[j-v[i]] f[j−v[i]]。

那么得到01背包问题的终极版代码：

#include <iostream>

using namespace std;

const int N = 1010;

int f[N];
int v[N], w[N];
int n, m;

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 = m; j >= v[i]; j -- )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

    cout << f[m];

    return 0;
}

3、完全背包

完全背包就是给出一些物品，但是物品数量不限。例题 acwing完全背包

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。
第 i 种物品的体积是 v i v_i vi​，价值是 w i w_i wi​。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行两个整数 v i v_i vi​, w i w_i wi​，用空格隔开，分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0< v i v_i vi​, w i w_i wi​≤1000
输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

10

还可以用 f ( i , j ) f(i,j) f(i,j)来表示：只在前 i i i个物品里面选，且背包容量为 j j j。
但是划分集合的时候，就和01背包略有不同了。因为物品是无限使用，所以划分为：

  1. 第 i i i件物品选了0个的选法： f ( i − 1 , j ) f(i-1,j) f(i−1,j)；
  2. 第 i i i件物品选了1个的选法： f ( i − 1 , j − v i ) + w i f(i-1,j-v_i)+w_i f(i−1,j−vi​)+wi​；
  3. 第 i i i件物品选了2个的选法： f ( i − 1 , j − 2 v i ) + 2 w i f(i-1,j-2v_i)+2w_i f(i−1,j−2vi​)+2wi​；
    ……
    第 i i i件物品选了s个的选法： f ( i − 1 , j − s v i ) + s w i f(i-1,j-sv_i)+sw_i f(i−1,j−svi​)+swi​，（ s × v i ≤ j s×v_i≤j s×vi​≤j）；

这样就能做到不重不漏地把 f ( i , j ) f(i,j) f(i,j)划分为了 s s s个集合。所以可以得到状态计算方程：
f ( i , j ) = m a x ( f ( i − 1 , j − k v i ) + k w i ) ， ( k = 0 , 1 , 2 , … , s ) f(i,j)=max(f(i-1,j-kv_i)+kw_i)，(k=0,1,2,…,s) f(i,j)=max(f(i−1,j−kvi​)+kwi​)，(k=0,1,2,…,s)

那么题解就有了：

#include <iostream>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N][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; k * v[i] <= j; 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;
}

可以进行进一步优化。这里注意到一个神奇的事情：
在这里插入图片描述
也即，当 v i ≥ j v_i≥j vi​≥j时，有 f ( i , j ) = f ( i , j − v i ) + w i f(i,j)=f(i,j-v_i)+w_i f(i,j)=f(i,j−vi​)+wi​。
有了这个，就可以对完全背包进行优化了：

#include <iostream>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N][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 (v[i] <= j) f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
        }

    cout << f[n][m] << endl;

    return 0;
}

这样少了一重循环，时间复杂度就变成O(mn)了。
再和01背包一样进行一维优化，得到最终版代码：

#include <iostream>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[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 ++ )
    	//注意这里的区别是j递增，和01背包相反，一定要想清为什么
        for (int j = v[i]; j <= m; j ++ )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

    cout << f[m] << endl;

    return 0;
}

j j j是递增的原因：公式中 f ( i , j ) f(i,j) f(i,j)的更新就是用本层的 f ( i , j − v i ) f(i,j-v_i) f(i,j−vi​)。

4、多重背包问题

完全背包就是给出一些物品，但是物品数量有限。例题 acwing多重背包

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 s i s_i si​ 件，每件体积是 v i v_i vi​，价值是 w i w_i wi​。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 v i v_i vi​, w i w_i wi​, s i s_i si​，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N≤1000
0<V≤2000
0< v i v_i vi​, w i w_i wi​, s i s_i si​≤2000
输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

用 f ( i , j ) f(i,j) f(i,j)来表示：只在前 i i i个物品里面选，且背包容量为 j j j。
划分集合的时候，因为物品是有限使用，所以划分为：

  1. 第 i i i件物品选了0个的选法： f ( i − 1 , j ) f(i-1,j) f(i−1,j)；
  2. 第 i i i件物品选了1个的选法： f ( i − 1 , j − v i ) + w i f(i-1,j-v_i)+w_i f(i−1,j−vi​)+wi​；
  3. 第 i i i件物品选了2个的选法： f ( i − 1 , j − 2 v i ) + 2 w i f(i-1,j-2v_i)+2w_i f(i−1,j−2vi​)+2wi​；
    ……
    第 i i i件物品选了 s i s_i si​个的选法： f ( i − 1 , j − s v i ) + s w i f(i-1,j-sv_i)+sw_i f(i−1,j−svi​)+swi​；

这样就能做到不重不漏地把 f ( i , j ) f(i,j) f(i,j)划分为了 s s s个集合。所以可以得到状态计算方程：
f ( i , j ) = m a x ( f ( i − 1 , j − k v i ) + k w i ) ， ( k = 0 , 1 , 2 , … ) f(i,j)=max(f(i-1,j-kv_i)+kw_i)，(k=0,1,2,…) f(i,j)=max(f(i−1,j−kvi​)+kwi​)，(k=0,1,2,…)
注意这里的 k v i kv_i kvi​一定是小于 j j j的。

那么就可以得到题解：

#include <iostream>

using namespace std;

const int N = 110;

int f[N][N];
int v[N], w[N], s[N];
int n, m;

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i] >> s[i];

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            for (int k = 0; k * v[i] <= j && k <= s[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;
}

但是浅看一下时间复杂度，三重循环，最坏 1000 × 2000 × 2000 1000×2000×2000 1000×2000×2000，大约是四十亿，明显超时了（C++每秒大概运算一亿次），所以就要优化。这里的优化是一个技巧，叫二进制优化。

假设有1023个物品，那么进行分组：20,21,22,23,24,…,29。也即1,2,4,8,…,512。用这几个数，就能组合出0 ~ 1023中所有的数。那么原来的1024（0 ~ 1023）个数，就变成了10个数进行组合。假如物品数不是2n-1个，例如45，那么就分组：20,21,22,23,24,45-24。也就是1,2,4,8,16,14。用这几个数就能组合出0 ~ 45所有的数了。

把分的每个组想成一个物品，其实就转化成了01背包问题，因为每组只能是选或不选。因此用01背包的代码即可解决，重点是分组。这时看一下时间复杂度，也就是 V × N × l o g s i V×N×logs_i V×N×logsi​，差不多 1000 × 2000 × l o g 2000 1000×2000×log2000 1000×2000×log2000，大概两千万，可以接受。那么给出优化的多重背包问题：

#include <iostream>

using namespace std;

//物品总数大概是N(组数)*log si(每组里的小组数)
//1000*log2000≈11000
const int N = 11010, M = 2010;

int f[N];
int v[N], w[N];
int n, m;

int main()
{
    cin >> n >> m;
    
    //分组
    int cnt = 0;
    for (int i = 1; i <= n; i ++ )
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s)
        {
            cnt ++ ;
            v[cnt] = k * a;
            w[cnt] = k * b;
            s -= k;
            k *= 2;
        }
        if (s > 0)
        {
            cnt ++ ;
            v[cnt] = s * a;
            w[cnt] = s * b;
        }
    }
    
    //分组后的物品数
    n = cnt;
    
    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]);
            
    cout << f[m] << endl;
    
    return 0;
}

5、分组背包问题

分组背包问题简单来说就是每组只能选一个物品或不选。
例题 acwing分组背包

有 N 组物品和一个容量是 V 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 v i j v_{ij} vij​，价值是 w i j w_{ij} wij​，其中 i 是组号，j 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 N 组数据：
每组数据第一行有一个整数 S i S_i Si​，表示第 i 个物品组的物品数量；
每组数据接下来有 S i S_i Si​ 行，每行有两个整数 v i j v_{ij} vij​, w i j w_{ij} wij​，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0< S i S_i Si​≤100
0< v i j v_{ij} vij​, w i j w_{ij} wij​≤100
输入样例

3 5
2
1 2
2 4
1
3 4
1
4 5

输出样例：

8

用 f ( i , j ) f(i,j) f(i,j)来表示：只在前 i i i组里面选，且背包容量为 j j j。
划分集合的时候，因为物品是有限使用，所以划分为：

  1. 第 i i i组物品不选的选法： f ( i − 1 , j ) f(i-1,j) f(i−1,j)；
  2. 第 i i i组物品选第1个的选法： f ( i − 1 , j − v i 1 ) + w i 1 f(i-1,j-v_{i1})+w_{i1} f(i−1,j−vi1​)+wi1​；
  3. 第 i i i组物品选第2个的选法： f ( i − 1 , j − v i 2 ) + w i 2 f(i-1,j-v_{i2})+w_{i2} f(i−1,j−vi2​)+wi2​；
    ……
    第 i i i组物品选第 s i s_i si​个的选法： f ( i − 1 , j − v i s i ) + w i s i f(i-1,j-v_{is_i})+w_{is_i} f(i−1,j−visi​​)+wisi​​；

由于思路较为简单，所以直接给出一维优化后的代码：

#include <iostream>

using namespace std;

const int N = 110;

int v[N][N], w[N][N], s[N];
int f[N];
int n, m;

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= n; i ++ )
    {
        cin >> s[i];
        for (int j = 1; j <= s[i]; j ++ )
            cin >> v[i][j] >> w[i][j];
    }
    
    for (int i = 1; i <= n; i ++ )
        for (int j = m; j >= 1; j -- )
            for (int k = 0; k <= s[i]; k ++ )
                if (v[i][k] <= j)
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
            
    cout << f[m] << endl;
    
    return 0;
}
HuaweiMian_
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划【背包问题】
yy080305的博客
12-05 180
三种基本的背包
【动态规划】 背包问题整理
findover的博客
09-30 487
【动态规划】 背包问题整理 背包问题03 题目类型描述： 给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择（每种物品数量不限），才能使得物品的总价格最高（from 百度百科）。 具象理解： 假设背包总容量top_weight为10，现共有四样物品（每样物品数目不限），他们的重量和价格分别为： 抽象建模：      &n...
动态规划解决01背包问题
01-17
01背包是在M件物品取出若干件放在空间为W的背包里，每件物品的体积为W1，W2至Wn，与之相对应的价值为P1,P2至Pn。01背包是背包问题中最简单的问题。动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。
一篇文章吃透背包问题！（细致引入+解题模板+例题分析+代码呈现）
weixin_52115456的博客
08-27 2166
背包问题背包问题解题模板典型题目1049. 最后一块石头的重量 II322. 零钱兑换416. 分割等和子集494. 目标和279. 完全平方数377. 组合总和 Ⅳ518. 零钱兑换 II1155. 掷骰子的N种方法 背包问题 背包问题： 背包问题是动态规划非常重要的一类问题，它有很多变种，但题目千变万化都离不开我根据力扣上背包问题的题解总结的解题模板。负责任地说，吃透这一篇文章，力扣上所有背包问题拿过来就可以秒杀！ 背包定义： 那么什么样的问题可以被称作为背包问题？换言之，我们拿到题目如何透过题目的不同
动态规划算法：背包问题
最新发布
2301_79881188的博客
06-02 1110
背包问题概述背包问题概述背包问题 (Knapsack problem) 是⼀种组合优化的NP完全问题。问题可以描述为：给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。根据物品的个数，分为如下⼏类：•01 背包问题：每个物品只有⼀个•完全背包问题：每个物品有⽆限多个•多重背包问题：每件物品最多有 si 个•混合背包问题：每个物品会有上⾯三种情况......•。
0-1_0-1背包_运筹学；背包问题_
10-04
该装备实现：? - 在一定约束（背包总容量）下，从数百种物品中选取出最优组合，使得总价值最大? -输出背包所能承载的物品组合的最大总价值，并给出所选物品的序号、价值和重量
【动态规划】背包问题（详细总结，很全）
m0_51370744的博客
10-07 2万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
背包问题大全（动态规划）
热门推荐
weixin_45746505的博客
05-02 6万+
背包问题是动态规划非常重要的一类问题，它有很多变种，但题目万变不离其宗。我们需要抓住关键的解题思路。
【算法与数据结构】—— 动态规划之背包问题
酱懵静的博客
03-15 2万+
背包问题分为多种，其中最常见的主要是三类：01背包、完全背包、多重背包。这里面最经典的是01背包问题，它基本上已经成为了事实上的动态规划入门级必学算法。下面，我们将对上述的三类背包问题逐个分析。
01背包问题
ccc369639963的博客
01-19 1万+
01背包问题 商店的货架上摆放着不同重量和价值的商品，一个小偷在商店行窃，他携带的背包只能装固定重量的商品。装哪些商品才能获得最大的收益呢？在限定条件内找到最佳的物品组合，这样的问题统称为背包问题。 根据限定的条件不同，背包问题还可以细分： 部分背包问题：所有物品是可再分的，即允许将某件物品的一部分（例如 1/3）放入背包； 0-1 背包问题：所有物品不可再分，要么整个装入背包，要么放弃，不允许出现“仅选择物品的 1/3 装入背包”的情况； 完全背包问题：不对每一件物品的数量做限制，同一件物品可以选择多个装
9大背包问题详解9大背包问题详解
08-23
背包问题是算法领域中经典的问题之一，属于动态规划的范畴。本资源摘要信息将对背包问题的九大变种进行详细解释，并对每种问题的解决思路、优化方法和算法进行阐述。 问题1：01背包问题 01背包问题是最基本的背包...
01背包问题和分数背包问题详解（动态规划和贪心算法）
05-10
01背包问题与分数背包问题是计算机科学中优化问题的经典实例，尤其在...在学习过程中，通过分析和实践如"01背包问题和分数背包问题详解（动态规划和贪心算法）.docx"这样的文档，可以深入理解这些概念并加强实战技能。
python基于递归解决背包问题详解
09-19
相比之下，动态规划可以通过存储子问题的解来避免重复计算，从而提高效率。然而，对于小规模问题，递归方法仍是一种有效的解决方案，其代码量少，逻辑清晰。 总结来说，Python中的递归可以优雅地解决背包问题，虽然...
背包问题详解
08-17
这篇文档主要介绍了所有背包问题的思路，包括01背包，完全背包和混合背包
Java学习之动态规划-背包问题代码
05-16
在所提供的压缩包文件中，"动态规划-背包问题代码.txt"很可能包含了上述逻辑的Java代码示例，而"DynamicProgramming——动态规划-背包问题详解.txt"可能提供了更详细的理论解释和分析。阅读这些文件将进一步深化你对...
动态规划问题举例详解
12-31
本文档对动态规划问题详细解释，举例很多，使初学者容易理解，绝对物超所值，希望大家下载观看 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。
背包问题（四种）
m0_53565874的博客
03-02 1万+
背包问题 文章目录背包问题一、背包模型（定义）二、01背包题目输入格式输出格式数据范围输入样例输出样例：题意思路二维AC代码一维AC代码三、完全背包题目输入格式输出格式数据范围输入样例输出样例：思路1朴素TLE代码思路2二维AC代码一维AC代码四、多重背包多重背包问题I题目输入格式输出格式数据范围输入样例输出样例：思路暴力AC代码多重背包问题II题目输入格式输出格式数据范围提示：输入样例输出样例：AC代码五、分组背包题目输入格式输出格式数据范围输入样例输出样例：思路AC代码 一、背包模型（定义） 01背包：
动态规划-背包问题
weixin_41082481的博客
04-21 7855
动态规划 动态规划（Dynamic Programming，简称DP）动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模
背包问题看这一篇就够了（详细版）
qq_54779611的博客
07-28 1万+
我们常说的背包问题其实分为好多种主要分为以下几种：01背包，完全背包，多重背包，分布背包。 所有的背包问题都是在有限V体积的背包中挑选物品，物品的属性分为w[i],v[i]表示第i个物品的价值和体积。从中找出那个能得到最大价值的选物品的方案。 通俗的来讲就是给你一个背包让你去装钻石每个钻石的价值和体积都是不一样的，最后你要装到最大价值的钻石。然后输出最大价值。 想要搞清楚这几种背包首先应该明白这几种背包的区别： 01背包 （每个物品只有一个，要么只选一个要么不选） 完全背包（每个物品有无数多个）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值