算法基础课—动态规划（一）背包问题

最新推荐文章于 2023-03-26 21:26:10 发布
最新推荐文章于 2023-03-26 21:26:10 发布
阅读量239 收藏 3
点赞数
分类专栏： 算法基础课 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yttttttttttttttt/article/details/117603418
版权

算法基础课—动态规划（一）背包问题

背包问题概述

在这里插入图片描述
多重背包问题——每个物品有有限个，si
分组背包问题——每一组只能选一个

01背包问题

题目

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

动态规划的关键

在这里插入图片描述
1、状态表示f（i，j）——需要几枚（有可能是i，或者i、j，或者i、j、t）来表示这个状态，如这里的条件是体积和包含前i个物品，于是我们可以把这两个作为状态中的i，j。而f（i，j）的值表达的则是他的属性，即这里的最大价值
集合——f（i，j）表示的是什么状态，i和j是什么，需要几个参数
属性——存的数集合的属性——如最大价值，最小代价等等

2、状态计算——如何进行状态转移
集合划分，如何把当前f（i，j）这个集合划分成更小的集合表示

第一种不含第i件物品，所以此时f（i，j） = f（i - 1， j）

第二种包含第i件物品，所以此时f（i，j）= f（i - 1，j - vi）+ wi 由于当前选法都包含第i件物品，所以我们可以去掉第i件物品，此时的他们的最大最小的排序也不会发生变化，所以找的就是在在不超过第i-1件物品内，体积不超过j-vi的最大值

最后的f（i，j）其实是他们两种情况取一个max
在这里插入图片描述

朴素做法

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

优化方法——滚动数组

关键：化成一维数组
优化可以发现在计算f（i，j）时，只用到了f（i-1，j）和f（i-1，j -vi）时的状态，而那时的j都是比较小的，所以可以把f化成一维数组来算

滚动数组，由于之后的每一次都只与上一次的有关系，且上一次的记录不需要保存，于是我们可以直接使用一维数组，每次使用然后覆盖即可

这里j用倒序是因为，如果说j是从v[i]开始的，则后续使用j-vi时，会变成使用的是第i次的，而需要的是第i-1次的，于是我们可以将j倒序进行循环

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

完全背包问题

题目

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

动态规划关键

状态转移方程：
在包含i的情况下，可能包含多个i，所以要考虑扣去1.。。k个i的情况，然后比较这几种情况和不包含情况中哪个最大
在这里插入图片描述

朴素做法

朴素做法由于是三层循环，所以会超时

//朴素做法
#include <iostream>
using namespace std;

const int N = 1010;
int n,m;
int f[N][N], v[N], w[N];
int main(){
    int i, j, k;
    cin>>n>>m;
    for(i = 1; i <= n; i ++){
        cin>>v[i]>>w[i];
    }
    for(i = 1; i <= n; i ++){
        for(j = 0; j <= m; j ++){
            for(k = 0; k * v[i] <= j; k ++)
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + w[i] * k);
        }
    }
    cout<<f[n][m]<<endl;
}

优化做法

优化的关键，就是发现f（i，j） 和 i，j有关f的关系，取出k的关系。
通过列举f（i，j） 和f（i, j-v) 发现规律，于是将f(i, j) 的值表示成和i，j有关的情况，于是会少去一层k循环。
在这里插入图片描述

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

再进一步的优化

上面是01背包，下面是完全背包，因此可以借鉴01背包的优化方法，区别在于一个是i-1 要从大到小，一个是i，要从小到大

在这里插入图片描述
于是也可以将其化为一维数组
注意是从小到大

//进一步的优化
#include <iostream>
using namespace std;

const int N = 1010;
int n,m;
int f[N], v[N], w[N];
int main(){
    int i, j, k;
    cin>>n>>m;
    for(i = 1; i <= n; i ++){
        cin>>v[i]>>w[i];
    }
    for(i = 1; i <= n; i ++){
        for(j = v[i]; j <= m; j ++){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout<<f[m]<<endl;
}

多重背包问题

与完全背包的差异在于指定了个数，于是k这里是min(s[i],j/v[i])
状态转移方程
在这里插入图片描述

题目

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000
提示：
本题考查多重背包的二进制优化方法。

输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

朴素做法

只适用于n较小的时候，因为是三层循环，如果n较大，很容易超时

//朴素做法
#include <iostream>
using namespace std;
const int N = 110;
int n,m;
int f[N][N], v[N], w[N], s[N];
int main(){
    int i, j, k;
    cin>>n>>m;
    for(i = 1; i <= n; i ++){
        cin>>v[i]>>w[i]>>s[i];
    }
    for(i = 1; i <= n; i ++){
        for(j = 0; j <= m; j ++){
            for(k = 0; k <= s[i] && 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;
}

关于不能采用完全背包的优化方法对多重背包进行优化的问题

优化——从状态转移方程入手去思考
如果从完全背包的角度去考虑
在这里插入图片描述

可以发现多出来一项，所以不能f[i,j]与f[i,j-v]之间的max不再存在包含的关系，所以不能直接使用完全背包的那种优化方法

优化做法——多重背包的二进制优化

将k化成二进制，每个二进制的代表数代表一个新的物体，用于对应倍数的体积和价钱
将k个，化成多个新物体
同时包含不同堆的情况，可以很好的表示所有可能

例子，不能选128，是因为这样可以表示超出200的数，所以选择200 - 127 = 73 ，这样可以表示。
在这里插入图片描述

//朴素做法
#include <iostream>
using namespace std;
const int N = 25000;
int n,m;
int f[N][N], v[N], w[N];
int main(){
    int i, j, k, cnt = 0;
    cin>>n>>m;
    int vv, ww, s;
    for(i = 1; i <= n; i ++){
        cin>>vv>>ww>>s;
        k = 1;
        while(k <= s){
            v[++ cnt] = k * vv;
            w[cnt] = k * ww;
            s -= k;
            k *= 2;
        }
        if(s > 0){
            v[++ cnt] = s * vv;
            w[cnt] = s * ww;
        }
    }
    n = cnt;
    for(i = 1; i <= n; i ++){
        for(j = 0; j <= m; j ++){
            f[i][j] = f[i - 1][j];
            if(j >= v[i])
                f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }
    cout<<f[n][m]<<endl;
}

再根据01背包进一步优化

//进一步优化
#include <iostream>
using namespace std;
const int N = 25000;
int n,m;
int f[N], v[N], w[N];
int main(){
    int i, j, k, cnt = 0;
    cin>>n>>m;
    int vv, ww, s;
    for(i = 1; i <= n; i ++){
        cin>>vv>>ww>>s;
        k = 1;
        while(k <= s){
            v[++ cnt] = k * vv;
            w[cnt] = k * ww;
            s -= k;
            k *= 2;
        }
        if(s > 0){
            v[++ cnt] = s * vv;
            w[cnt] = s * ww;
        }
    }
    n = cnt;
    for(i = 1; i <= n; i ++){
        for(j = m; j >= v[i]; j --){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout<<f[m]<<endl;
}

分组背包问题

其实有点像01背包，只不过区别在于一组内有多个物品可以选择，所以要依次比较

题目

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

动态规划

在这里插入图片描述

优化做法

//优化做法
#include <iostream>
using namespace std;
const int N = 1010;
int n,m;
int f[N], v[N][N], w[N][N], k[N];
int main(){
    int i, j, t;
    cin>>n>>m;
    for(i = 1; i <= n; i ++){
        cin>>k[i];
        for(j = 0;j < k[i]; j ++){
            cin>>v[i][j]>>w[i][j];
        }
    }
    for(i = 1; i <= n; i ++){
        for(j = m; j >= 0; j --){
            for(t = 0; t < k[i]; t ++ ){
                if(j >= v[i][t])
                f[j] = max(f[j], f[j - v[i][t]] + w[i][t]);
            }
        }
    }
    cout<<f[m]<<endl;
}
肥肥饼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
区间调度之区间合并问题
wolfGuiDao的博客
03-07 666
区间调度之区间合并问题 还是先看一道题： 一、解题思路 一个区间可以表示为 [start, end]，区间重叠区间调度问题，需要按 end 排序，以便满足贪心选择性质。而对于区间合并问题，其实按 end 和 start 排序都可以，不过为了清晰起见，我们选择按 start 排序。 显然，对于几个相交区间合并后的结果区间 x，x.start 一定是这些相交区间中 start 最小的，x.end ...
算法基础入门：90分钟搞定动态规划
06-17
动态规划（Dynamic programming，简称DP）很多人都觉得是比较难以理解和掌握的一种算法，为了应付面试更多的时候程序员会选择直接死记硬背斐波那楔数列或者背包问题的源码，其实只要认真学习、彻底理解，动态规划并...
算法基础课：动态规划之背包问题
weixin_45854106的博客
07-03 198
首先动态规划，应该理解为一个递推的过程，很多时候对于动态规划来说都应该是从前向后递推的一个过程。但是思考的方式还是应该按照递归的思想来去思考，比如说按照集合划分，状态表示，状态表示又可以划分成状态表示的东西是什么？状态表示的条件是什么，属性又是什么？状态计算就是正常的一个递推的过程，思考方式是该属性可以来源于哪些部分，然后然后以递推的方式进行即可。 01背包：每个物体只有选与不选。 完全背包：每个物体可以选择无数次。 多重背包：每个物体只能选择有限次。 分组背包：分成若干组，每次只能从每组之中选择一个（类似
【算法——动态规划一】：背包问题
m0_61960885的博客
08-20 174
acwing
【算法】动态规划-背包问题
每天更新大数据面经和技术
04-28 473
  动态规划就是将问题划分为子问题，通过子问题的最优解得到原问题的最优解。动态规划把每个求解过程的子问题记录下来，下次碰到同样的子问题可以直接使用之前的结果。下面学习一类经典的背包问题。 1.01背包问题 问题是这样的：n 件物品，每个重量 w[i]，价值 c[i] 。背包容量 V。问如何使得背包内物品总价值最大。每种物品只有一件。 定义 dp[i][j] 表示前 i 件物品装入容量 j 的背包的价值，那么： dp[i][j] = Math.max( dp[i-1][j], // 不放第 i 件物品
[算法基础]动态规划——背包问题
Protein_zmm的博客
05-26 187
01背包问题 N个物品，容量为V的背包 物品有两个数学——Vi体积，Wi价值 每件物品最多使用一次——要么使用0次、要么使用1次，最多使用一次 使得背包能装得下的情况下，最大价值为多少？ #include <iostream> #include <algorithm> using namespace std; const int N = 1010; int v[N], w[N]; // 体积和价值的数组 int f[N][N]; int main() { int n, m;
class1_算法基础课_左神_
09-29
总的来说，左神的算法基础课是一次全面而深入的算法之旅，无论你是编程新手还是有一定经验的开发者，都能从中受益匪浅。通过系统的学习，你将掌握算法的思维方式，提升解决问题的能力，为自己的编程生涯打下坚实的...
AcWing算法基础课模板大全
07-14
【AcWing算法基础课模板大全】是一门涵盖了基础算法、数据结构以及相关代码模板的课程，旨在帮助学习者熟练掌握编程中常见的算法和数据结构的实现。以下将详细阐述这些知识点： ### 1. 基础算法 **快速排序算法...
动态规划第1课PPTX
08-06
解决动态规划问题通常有两种基本策略：自底向上和自顶向下。自底向上方法从最小规模的子问题开始，逐步构建到大问题；自顶向下方法则从大问题开始，通过递归调用逐步分解到子问题。在实际应用中，往往结合这两种...
动态规划入门第3课的PPT
最新发布
08-06
动态规划（Dynamic Programming）是一种算法设计方法，通过将复杂的问题拆分成多个小问题，并使用递归和 memoization 来解决问题。它常用于解决具有 optimal substructure 的问题，即问题可以被分解成多个小问题，...
【动态规划】背包问题（详细总结，很全）
热门推荐
m0_51370744的博客
10-07 3万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
01背包问题-每个物品只能选一次-动态规划dp[i][j]
weixin_45794299的博客
03-24 1874
一、题目 有N件物品和一个最多能被重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。 二、思路 三、代码 void test_2_wei_bag_problem1() { vector<int> weight = {1, 3, 4}; vector<int> value = {15, 20, 30}; int bagWeight = 4; /
【算法】----01背包问题（动态规划）
云小逸的博客
03-26 3217
今天我们来学习一下一个经典Dp问题----背包问题，这里将详细介绍背包问题的二维解法和一维解法。码字不易，请多多支持。
背包问题总结
fuzekun的博客
03-13 98
三.分组背包 for(分组i){ for(int j = V; j > 0; j--){ for(分组i中的k){ f[j] = f[j - w[k]] + v[k]; } } } 四.多重背包 题目 有NNN种物品和一个容量为VVV的背包。第iii种物品最多有p[i]p[i]p[i]件可用，每件费用是w[i]w[i]w[i]，价值是v[i]v[i]v[i]。求解将哪些物...
闫式DP分析法笔记Java实现(01背包，完全背包，区间合并，最长公共子序列）
qq_40180352的博客
02-20 261
01背包问题 题目：https://www.acwing.com/problem/content/2/ 思路： //01背包暴力解法 import java.util.Scanner; public class TestA { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(),V = sc.next
【算法与数据结构】—— 动态规划之背包问题
酱懵静的博客
03-15 2万+
背包问题分为多种，其中最常见的主要是三类：01背包、完全背包、多重背包。这里面最经典的是01背包问题，它基本上已经成为了事实上的动态规划入门级必学算法。下面，我们将对上述的三类背包问题逐个分析。
动态规划之背包问题篇
PL_hfc的博客
11-05 494
动态规划（Dynamic--Planning），简称DP。一、求解背包问题的算法归纳——以背包问题为例1）如果装不下当前物品，那么前n个物品的最佳组合和前n-1个物品的最佳组合是一样的。2）如果装得下当前物品。假设1 :装当前物品，在给当前物品预留了相应空间的情况下，前n-1 个物品的最佳组合加上当前物品的价值就是总价值。假设2:不装当前物品，那么前n个物品的最佳组合和前n-1个物品的最佳组合是-样的。选取假设1和假设2中较大的价值，为当前最佳组合的价值。
动态规划算法（背包问题）
m0_57385165的博客
08-28 534
1.应用场景-背包问题 背包问题：有一个背包，容量为4磅 ，现有如下物品 1)要求达到的目标为装入的背包的总价值最大，并且重量不超出 2)要求装入的物品不能重复 2.动态规划算法介绍 1)动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法 2)动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，...
动态规划——背包问题（详解）
qq_61896131的博客
03-08 9143
动态规划是我最早接触的算法，一开始非常简单，固定模板题，后来愈发愈发难起来了，条件，状态压缩等等，难点主要是，状态怎么表示，状态转移方程怎么写，这篇文章将会从背包五大问题详解，希望能帮助到大家去类比，思考其他动态规划题目。 首先先来看看动态规划的定义： 动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。
算法基础课：代码模板全集
动态规划是一种解决复杂问题的有效方法，涉及背包问题、线性DP、区间DP、计数类DP、数位统计DP、状态压缩DP、树形DP和记忆化搜索等。每种类型的DP问题都有自己的状态转移方程和解决策略。 总结，这个资源为学习算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值