蓝桥杯算法基础(36)动态规划dp经典问题详解

动态规划
-动态规划方法方法代表了这一类问题(最优子结构or子问题最优性)的有一半解法,是设计方法或者策略,不是具体算法
-本质是递推,核心是找到状态转移的方式,写出dp方程
-形式:记忆性递归递推

01背包问题

 

有n个重量和价值分别为wi,vi的物品,从这些物品中挑选出总重量不超过n的物品,求所有挑选方案中的值总和的最大值
1<=n<=1002
1<=wi,vi<=100
1<=w<=10000输入、n=4(w,v)={(2,3),(1,2),(3,4),(2,2)}w=5
输出7{选择第0,1,3号物品}因为对每个物品只有选和不选两种情况,所以这个问题称为01背包public class Case_01背包问题{static int[] w={2,1,3,2};//重量表static int[] v={3,2,4,2};//价值表static int n=4;//物品数量static int W=5;//背包的承重极限public static void main(String[] args){int ww=W;int ans=dfs(0,ww);System.out.println(ans);}static int dfs(int i,int ww){if(w<=0)return 0;//装不进去if(i==n)return 0;//每东西可选了int v2=dfs(i+1,ww);//不选择当前物品if(ww>=w[i]){int v1=v[i]+dfs(i+1,ww-w[i]);//选择当前物品return max(v1,v2);;}else{return v2;}}
static int[][] rec;
}重叠求解,记忆性递归
重叠子问题,不重复求解public static void main(String[] args){int ww=W;int ans=dfs(0,ww);System.out.println(ans);rec=new int[n][w+1];for(int i=0;i<n;i++){Arrays.fill(rec[i],-1);//每一行都填充为-1}ans=m(m,v,0,n,W);System.out.println(ans);}static int m(int i,int ww){mif(w<=0)return 0;//装不进去if(i==n)return 0;//每东西可选了//计算之前做查询if(rec[i][ww]>=0){return rec[i][ww];}int v2=m(i+1,ww);//不选择当前物品if(ww>=w[i]){int v1=v[i]+m(i+1,ww-w[i]);//选择当前物品ans=max(v1,v2);;}else{ans=v2;}//计算之后做保存rec[i][ww]=ans;return ans;}01背包问题dp(dynamic programming)
(w,v)  0   1           2           3              4            5
(2,3)  0   0           3           3              3            3
(1,2)  0   2 要2+0,不要3 5=要2+3,不要3 5=要2+3,不要3 5=要2+3,不要3
(3,4)  0   2           3     5=4+0,5        6=4+2,5      7=4+3,5
(2,2)  0   2           3           5              6            7定义从小到大的背包,初始化第一行,然后根据第一行去推其他行
看当前背包是否能装下给这个物品,若是装不下,则取上一行相同容量背包的最大价值为当前这个背包的价值
若是能装下,则要比较两种情况,选与不选,若选择这个物品,这加上这个物品的价值,背包则减去这个物品的容量,
剩余的容量肯定比之前小,则在上一行找剩余容量的最大价值,两者相加,即为选择这个物品的最大价值,若是不选,
则取上一行的最大价值为当前最大价值,比较选与不选两者的最大值,取最大值作为当前背包的最大价值
当dp到最后,右下角即为答案static int dp(){int[][] dp=new int[n][w+1];//初始化dp表的第一行for(int i=0;i<W+1;i++){if(i>=w[0]){//每种容量0号的物体dp[0][i]=v[0];}else{dp[0][i]=0;}}//其他行for(int i=1;i<n;i++){for(int j=0;j<W+1;j++){if(j>=w[i]){//要的起int i1=v[i]+dp[i-1][j-w[i]];//选择当前物品int i2=dp[i-1][j];//不选dp[i][j]=max(i1,i2);}else{dp[i][j]=dp[i-1][j];}}}return dp[n-1][W];}

 钢条分割

 

Serling公司,购买长钢条,将其切割为短钢条出售,切割工序本身没有成本支出,公司管理层希望知道最佳的切割方案
假定我们知道Serling公司出售一段长为i英寸的的钢条价格为pi(i=1,2,...单位为美元),钢条长度均为整英寸| 长度i | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| - | - | - | - | - | - | - | - | - | - |
价格pi  | 1 | 5 | 8 | 16 | 10 | 17 | 17 | 20 | 24 | 30 |钢条切割问题是这样的,给定一段长度为n英寸的钢条和一个价格表pi(i=1,2...n),求切割钢条方案,使得售价收益rn最大,
注意,如果长度为n英寸的钢条的价值pn足够大,最优解可能就是完全不需要切割递归->记忆性递归->dppublic class Case_钢条切割{//有重复子问题static int r(int x){if(x==0){return 0;}int ans=0;for(int i=1;i<=x;i++){//取不同种切法的最大值int v=p[i-1]+r(x-i);//p[i-1即]从不切开始ans=max(v,ans);}return ans;}static int[] vs=new int[n+1];static int r1(int x){if(x==0){return 0;}int ans=0;for(int i=1;i<=x;i++){//取不同种切法的最大值if(vs[x-i]==-1)vs[x-i]=r1(x-i);int v=p[i-1]+vs[x-i];//p[i-1]为这么长的钢材不切割时的价钱从不切开始ans=max(v,ans);}vs[x]=ans;return ans;}static int dp(){vs[0]=0;for(int i=1;i<=n;i++){//拥有钢条长度for(int j=1;j<=i;j++){vs[i]=max(p[j]+vs[i-j],vs[i]);}}return vs[n];}}

数字三角形

 

在数字三角形中寻找一条从顶部到底边的路径,使得路径上所经过的数字之和最大
路径上的每一步都只能网左下或右下走。只需要求出这个最大和即可,不必给出具体路径。
三角形的行数大于1小于等于100,数字为(0~9)
输入格式:
5//表示三角形的行数。接下来输入三角形73 88 1 02 7 4 44 5 2 6 5
要求输出最大和dfs
public static int maxSumUsingRecursive(int[][] triangle,int i,int j){int rowIndex=triangle.length;if(i==rowIndex-1){return triangle[i][j];}else{//顶点的值+max(左侧支线的最大值,右侧支路的最大值)return triangle[i][j]+Math.max(maxSumUsingRecursive(triangle,i+1,j),maxSumUsingRecursive(triangle,i+1,j+1));}}dp递推
打表法public static int maxSumUsingDp(int[][],int i,int j){int rowCount=triangle.length;//行数int columnCount=triangle[rowCount-1].length;//最后一行的列数int[][] dp=new int[rowCount][ColumnCount];for(int k=0;k<columnCount;k++){dp[rowCount-1][k]=trianle[rowCount-1][k]//初始化最后一行}for(int k=rowCount-2;k>=0;k--){for(int l=0;l<k;l++){dp[k][l]=triangle[k][l]+max(dp[k+1][l+1])}}return dp[0][0];}可以用滚动数组,来表示,底下一层求完,就没用了,可以覆盖掉public static int maxSumUsingDp(int[][],int i,int j){int rowCount=triangle.length;//行数int columnCount=triangle[rowCount-1].length;//最后一行的列数int[] dp=new int[ColumnCount];for(int k=0;k<columnCount;k++){dp[k]=trianle[rowCount-1][k]//初始化最后一行}for(int k=rowCount-2;k>=0;k--){for(int l=0;l<k;l++){dp[l]=triangle[k][l]+max(dp[k+1][l+1])}}return dp[0][0];}

 最长公共子序列

求最大公共子序列
AB34C
A1BC2结果为ABC
更多案例请看测试用例ArrayList<Character>dfs(String s1,String s2){int len1=s1.length();int len2=s2.length();ArrayList<Character> ans=new ArrayList<>;for(int i=0;i<len1;i++){//以i字符开头的公共子序列ArrayList<Character> list=new ArrayList<>;//和s2的每个字符【【比较for(int j=0;j<len2;j++){if(s1.charAt(i)==s2.charAt(j)){//如果相同list.add(A1.charAt(i));list.addAll(dfs(s1.substring(i+1),s2.substring(j+1)));break;}}if(list.size()>ans.size()){//以不同字符开头公共序列,求最长ans=list;}}}dpB A 3 4 C  s1
A 0 1 1 1 1
1 0 1 1 1 1
B 1 1 1 1 1
C 1 1 1 1 2
2 1 1 1 1 2
s2
当找到相同的字符,每个位置,都找左、上、和左上角+1的最大值,若没有找到相同字符,则找左、上 的最大值
String solution(String s1,String s2){int len1=s1.length();int len2=s2.length();int[][] dp=new int[len1+1][len2+1];//动规数组int flag=0;//初始化第一行for(int i=1;i<=len1;i++){if(flag==1){dp[i][1]=1;}else if(s1.charAt(i-1)==s2.charAt(0){dp[i][1]=1;flag=1;}else{dp[i][1]=0;}}for(int i=2;i<=len1;i++){//Mfor(int j=2;j<=len2;j++){int maxOfleftAndUp=Math.max(dp[i-1][j],dp[i][j-1]);if(s1.charAt(i-1)==s2.charAt(j-1)){//从1开始的数组,所以要i-1dp[i][j]=Math.max(maxOfleftAndUp,dp[i-1][j-1]+1);}else{dp[i][j]=maxOfLeftAndUp;}}}return parseDp(dp,s1,s2);}//还原子最长子序列
private String parseDp(int[][] dp,String s1,String s2){int M=s1.length();int N=s2.length();StringBuilder sb=new StringBuilder();while(M>0&&N>0){//比左和上大,一定是当前位置的字符相等if(dp[M][N]>Math.max(dp[M-1][N],dp[M][N-1])){sb.insert(0,s1.charAt(M-1));M--;N--;}else{//一定选择的是左边和上边的大者if(dp[M-1][N]>dp[M][N-1]){M--;//往上移}else{N--;//往左移}}}return sb.toString();
}dp状态转移方程
用已知来推未知

完全背包问题

 

有n个重量和价值分别为wi,vi的物品,从这些物品中挑选出总重量不超过w的物品,求所有挑选方案中的价值总和的最大值(w,v)={(2,3),(1,2),(3,4),(2,2)}0  1  2  3  4  5  6  7  8  9  10
(2,3)  0  0  3  3  6  6  9  9 12 12  15
(1,2)  0  2 2+2 2+4......
(3,4)  0  2  4  6
(2,2)两个核心式子:
拿一个后,剩余容量找当前行和上一行的最大值,一个不拿,找上一行该列的值,比较拿与不拿的最大值
该行前面就包含了不选的情况,当容量不足时,取上一行该容量的价值
因为需要选的物品重量价值不同,会出现当前行的该容量的价值比上一行的价值要大的情况
dp[i][j]=Math.max(v[i]+dp[i][ww-w[i]],dp[i-1][j])
上一行的该列,意味着旧的该容量价值的最大值,新的该容量的价值与旧的取最大值
因此上面求出来的dp还要和上一行dp比较一下
dp[i][j]=Math.max(dp[i][j],d[i-1][j])

最长递增子序列

 

输入4 2 3 1 5 6
输出3(因为 2 3 5 组成了最长递增子序列)
public class Case_最长递增子序列{public static void main(String[] args){int[] arr={4,2,3,1,5};System.out.println(f(arr));}private static int f(int[] arr){for(int i=0;i<arr.length;i++){int p=i;int cnt=0;for(int j=i+1;j<arr.length;j++){if(arr[j]>arr[p]){cnt++;p=j;}}if(cnt>maxCnt){maxCnt=cnt;}}//maxCnt=max(maxCnt,cnt);}return maxCnt;}dp
4 2 3 1 5 6
1 1 2 1 3 4并不是说最后一个就是最大递增子序列
把每位求出来,最后再整体作一个maxstatic int[] dp=new int[arr.length];
private static int dp(int[] arr){dp[0]=1;//初始化第一位为1for(int i=0;i<arr.length;i++){//每个位置cnt=1;for(int j=i-1;j>=0;j--){//向前找比当前位置小的if(arr[i]>arr[j]){cnt=max(dp[j]+1,cnt);}}dp[i]=cnt;}int ans=-1;for(int i=0;i<sb.length;i++){ans=max(ans,dp[i]);}return ans;
}dp[i]
长度为i最长递增子序列(LIS)最末尾的数避免陷入思维定势
初始化第一个元素,遍历剩余的元素,若是比最后一个dp元素大,则添加到其后面,若是比它小,则放在dp数组第一个大于arr的元素位置上4 2 3 1 5 6 4 8 5 9
4[1]
2[1] 3[2]
1[1] 3[2]
1[1] 3[2] 5[3]
1[1] 3[2] 5[3] 6[4]
1[1] 3[2] 4[3] 5[4] 8[5] 9[6]结果为6private static int dp1(int[] arr){dp=new int[arr.length];dp[1]=arr[0];//长度为1的最长递增子序列,初始化为第一个元素int p=1;//记录dp更新的最后位置for(int i=1;i<arr.length;i++){if(arr[i]>dp[p]){dp[p+1]=arr[i];p++;}else{//扫描dp数组,替换第一个比arr大的//可以用二分法,优化查找for(int j=0;j<=0;j++){if(dp[i]>arr[i]){dp[i]=arr[i];break;}}}}return 0;
}

 

小结
动态规划用于解决多阶段决策最优化问题
三要素:
-阶段
-状态
-决策
两个条件:
-最优子结构(最优化原理)
-无后效性:当前状态是前面状态的完美总结是否可以用动态规划,否则用搜索
-模型匹配:多做题,掌握经典模型一维:上升子序列模型,背包波形二维:最长公共子序列问题
-寻找规律:规模由小到大,或者由大到小,做逐步分许
-放宽条件或增加条件
一般过程-找到过程演变中变化的量(状态),以及变化的规律(状态转移方程)-确定一些初始状态,通常需要dp数组来保存-利用状态转移方程,退出最终答案
解法-自顶向下,递归:如果有重叠子问题,带备忘录-自底向上,递推贪心和动规可以用局部最优解来推导全局最优解,即动态规划贪心:这一阶段的解,由上一阶段直接推导出动规:当前问题的最优解,不能从上一阶段子问题简单得出,需要前面多杰阶段多层子问题共同计算出,因此需要保留历史上求解过的子问题及其最优解

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/791271.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

FreeRTOS中断管理以及实验

FreeRTOS中断管理以及实验 继续记录学习FreeRTOS的博客&#xff0c;参照正点原子FreeRTOS的视频。 ARM Cortex-M 使用了 8 位宽的寄存器来配置中断的优先等级&#xff0c;这个寄存器就是中断优先级配置寄存器 &#xff0c; STM32寄存器中并且这个寄存器只使用[7:4]&#xff0c…

Rust 中的字符串类型:`str` 和 `String`

Rust 中的字符串类型&#xff1a;&str 和 String 文章目录 Rust 中的字符串类型&#xff1a;&str 和 String1. &str&#xff1a;不可变的字符串引用2. String&#xff1a;可变的字符串3、字符串使用综合案例代码执行结果 在 Rust 编程语言中&#xff0c;有两种主要…

RTX RTOS 操作实例分析之---线程(thread)

0 Preface/Foreword 1 线程&#xff08;thread&#xff09; 1.1 线程定义 1.1.1 USE_BASIC_THREADS&#xff08;宏定义&#xff09; 经过以上步骤&#xff08;makefile包含&#xff09;&#xff0c;USE_BASIC_THREADS在编译阶段被定义到相应的模块中。 1.1.2 定义线程ID变量…

安装Pillow库的方法最终解答!_Python第三方库

安装Python第三方库Pillow 我的环境&#xff1a;Window10&#xff0c;Python3.7&#xff0c;Anaconda3&#xff0c;Pycharm2023.1.3 pillow库 Pillow库是一个非常强大的图像处理库。它提供了广泛的图像处理功能&#xff0c;让我们可以轻松地读取和保存图像、创建缩略图和合并到…

Java学习day5-面向对象2

构建标准JavaBean快捷方式 快捷键&#xff1a;altinsert(Fn)->构造函数->全选构造带参方法&#xff0c;不选择则空参构造 插件&#xff1a;ptg,安装后右键单击&#xff0c;倒数第三个则为一键构造所有set/get函数 数据类型 基本数据类型&#xff1a;数据值存储在自己的…

欧拉路径欧拉回路

欧拉回路&#xff0c;指遍历图时通过图中每条边且仅通过一次&#xff0c;最终回到起点的一条闭合回路&#xff0c;适用于有向图与无向图&#xff0c;如果不强制要求回到起点&#xff0c;则被称为欧拉路径。 欧拉图&#xff1a;具备欧拉回路的图 无向图&#xff1a;图的所有顶…

代码随想录 Day37 738.单调递增的数字 968.监控二叉树

738.单调递增的数字 class Solution { public:int monotoneIncreasingDigits(int N) {string strNum to_string(N);// flag用来标记赋值9从哪里开始// 设置为这个默认值&#xff0c;为了防止第二个for循环在flag没有被赋值的情况下执行int flag strNum.size();for (int i s…

37-巩固练习(一)

37-1 if语句等 1、问&#xff1a;输出结果 int main() {int i 0;for (i 0; i < 10; i){if (i 5){printf("%d\n", i);}return 0;} } 答&#xff1a;一直输出5&#xff0c;死循环 解析&#xff1a;i5是赋值语句&#xff0c;不是判断语句&#xff0c;每一次循…

路径规划——曲线拟合详解(一):多项式轨迹与QP优化(minimum-snap算法核心部分)

前言 历经一个多星期时间&#xff0c;我们在路径规划——搜索算法部分讲解了7种常见的路径搜索算法&#xff0c;每一种算法的链接放在下面了&#xff0c;有需要的朋友点击跳转即可&#xff1a; 路径规划——搜索算法详解&#xff08;一&#xff09;&#xff1a;Dijkstra算法详…

由平行公设的不同而来三种几何学浅谈

由平行公设的不同而来三种几何学浅谈 欧几里德的《几何原本》 欧几里德的《几何原本》一开始就给出了23个定义&#xff0c;5个公设&#xff0c;5个公理。 23个定义(部分)&#xff1a; 点是没有部分的东西。 线是没有宽度的长度。 线的端点是点。 直线是各点都在同一方向上…

GraalVM运行模式和企业级应用

文章目录 GraalVM运行模式JIT模式AOT模式 GraalVM的问题和解决方案GraalVM企业级应用传统架构的问题Serverless架构函数计算Serverless应用场景Serverless应用 GraalVM内存参数 GraalVM运行模式 JIT模式 JIT&#xff08; Just-In-Time &#xff09;模式 &#xff0c;即时编译模…

重置gitlab root密码

gitlab-rails console -e production user User.where(id: 1).first user User.where(name: "root").first #输入重置密码命令 user.password"admin123!" #再次确认密码 user.password_confirmation"admin123!" #输入保存命令&am…

单例(Singleton)设计模式总结

1. 设计模式概述&#xff1a; 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。 就像是经典的棋谱&#xff0c;不同的棋局&#xff0c;我们用不同的棋谱。"套路"经典的设计模式一共有…

Ruby 之交租阶段信息生成

题目 我看了一下&#xff0c;这个题目应该不是什么机密&#xff0c;所以先放上来了。大概意思是根据合同信息生成交租阶段信息。 解答 要求是要使用 Ruby 生成交租阶段信息&#xff0c;由于时间比较仓促&#xff0c;变量名那些就用得随意了些。要点主要有下面这些&#xff1a…

【介绍什么是DDOS】

&#x1f308;个人主页:程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…

Qt 的发展历史、现状与启示

Qt 最早在1991年由挪威的两位程序员 Eirik Chambe-Eng 和 Haavard Nord 开发&#xff0c;他们在1994年创立 Trolltech 公司&#xff08;奇趣科技&#xff09;正式经营软件业务。Qt 的第一个公众预览版于1995年面世&#xff0c;之后在2008年被诺基亚收购&#xff1b;2011年到201…

【C++】编程规范之内存规则

在高质量编程中&#xff0c;内存管理是一个至关重要的方面。主要有以下原则&#xff1a; 内存分配后需要检查是否成功&#xff1a;内存分配可能会失败&#xff0c;特别是在内存紧张的情况下。因此&#xff0c;在分配内存后&#xff0c;应该检查分配是否成功。 int* ptr new …

【ZZULIOJ】1030: 判断直角三角形(Java)

目录 题目描述 输入 输出 样例输入 Copy 样例输出 Copy code 题目描述 输入三个正整数&#xff0c;判断用这三个整数做边长是否能构成一个直角三角形。 输入 输入三个正整数。 输出 能否构成直角三角形。如能输出&#xff1a;yes.若不能&#xff0c;输出&#xff1a…

java操作mongodb详解

前言 一切操作都应该以官方文档为准&#xff0c;mongodb官网文档地址&#xff1a; https://www.mongodb.com/docs/ &#xff0c;网上关于java操作mongodb的文章偏少&#xff0c;而且有些乱。这篇文章是在项目中使用mongodb后的一些总结&#xff0c;希望能帮到大家。 1.创建mon…

(译) 理解 Elixir 中的宏 Macro, 第四部分:深入化

Elixir Macros 系列文章译文 [1] (译) Understanding Elixir Macros, Part 1 Basics[2] (译) Understanding Elixir Macros, Part 2 - Macro Theory[3] (译) Understanding Elixir Macros, Part 3 - Getting into the AST[4] (译) Understanding Elixir Macros, Part 4 - Divin…