Java:实现动态规划的4个经典题型,你都会吗?拒绝做优秀的码农

经典动态规划算法题(Java实现) 待更新 阅读详情

01 前言

1.1 说明

关于动态规划的见解:动规和递归有很多相似的地方,最显著的特征可以说是阶段性,二者都有很明显的阶段划分,所以,声明好每一个阶段所需要做的事情以及阶段与阶段之间的转移可以说是重中之重了,这就涉及几个问题:

  • 第一,需要声明好方法(递归)或者数组(动规)具体的意义,所代表的作用;
  • 第二,需要说明好递归处理数据的方式(递归)或者是阶段转移方程(动规);
  • 第三,跳出方法的条件(递归)或者是数组边界条件(动规)。

处理好这三个方面,基本上就没有问题,剩下的就是一些边边角角的问题。

1.2 提炼

  • 声明数组代表的含义
  • 状态转移方程
  • 边界条件

除了动态规划的4个题型的分析,小编最近还整理了66个Java面试的知识点哦(提示:文末有福利)

02 4个经典题型

2.1 数字金字塔

(1)问题描述

观察下面的数字金字塔。写一个程序查找从最高点到底部任意处结束的路径,使路径经过数字的和最大。每一步可以从当前点走到左下方的点也可以到达右下方的点。

在上面的样例中,从13到8到26到15到24的路径产生了最大的和86。

(2)输入

第一个行包含R(1<= R<=1000),表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。

所有的被供应的整数是非负的且不大于100。

(3)输出

单独的一行,包含那个可能得到的最大的和。

(4)样例输入

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">5 //数塔层数
13
11 8
12 7 26
6 14 15 8
12 7 13 24 11
</pre>

(5)样例输出

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">86
</pre>

(6)代码1

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">    /**
 * 顺推 dp
 * 含义:f[x][y] 从0,0到x,y最大值
 * 方程:f[x][y] = max{f[x-1][y],f[x-1][y-1]} + a[x][y]
 * 边界:f[0][0] = a[0][0]
 * */
 public int positive(int[][] a) {
 int[][] f = new int[a.length][a.length];
 // 边界
 f[0][0] = a[0][0];
 // 状态转移方程
 int i,j;
 for (i=1; i<a.length; i++) {
 for (j=0; j<=i; j++) {
 /*判断是否数组越界,左右两边需单独处理*/
 if (j == 0) {
 f[i][j] = f[i-1][j] + a[i][j];
 } else if (j == i) {
 f[i][j] = f[i-1][j-1] + a[i][j];
 } else {
 int max = f[i-1][j] > f[i-1][j-1] ? f[i-1][j] : f[i-1][j-1];
 f[i][j] = max + a[i][j];
 }
 }
 }
 // 获取最大值
 int temp = 0;
 for (i=0; i<a.length; i++) {
 if (f[a.length-1][i] > temp) {
 temp = f[a.length-1][i];
 }
 }
 return temp;
 }
</pre>

(7)代码2

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">    /**
 * 逆推
 * 含义:f[x][y]表示从x,y到终点的最大值,所以f[0][0]即为所求
 * 公式:f[x][y] = max{f[x+1][y+1],f[x+1][y]} + a[x][y]
 * 边界:f[length-1][0...length-1] = a[length-1][0...length-1]
 * */
 public int negative(int[][] a) {
 int[][] f = new int[a.length][a.length];
 // 边界
 int i,j;
 for (i=0; i<a.length; i++) {
 f[a.length-1][i] = a[a.length-1][i];
 }
 // 状态转移
 for (i=a.length-2; i>=0; i--) {
 for (j=0; j<=i; j++) {
 int max = f[i+1][j+1] > f[i+1][j] ? f[i+1][j+1] : f[i+1][j];
 f[i][j] = max + a[i][j];
 }
 }
 return f[0][0];
 }
</pre>

2.2 最长不下降子序列

(1)问题描述

设有由n个不相同的整数组成的数列,记为:b(1)、b(2)、……、b(n)且b(i)<>b(j) (i<>j),若存在i1<i2<i3< … < ie 且有b(i1)<b(i2)< … <b(ie)则称为长度为e的不下降序列。程序要求,当原数列出之后,求出最长的不下降序列。

例如13,7,9,16,38,24,37,18,44,19,21,22,63,15。

例中13,16,18,19,21,22,63就是一个长度为7的不下降序列,

同时也有7 ,9,16,18,19,21,22,63长度为8的不下降序列。

(2)算法分析

根据动态规划的原理,由后往前进行搜索(当然从前往后也一样)。

对b(n)来说,由于它是最后一个数,所以当从b(n)开始查找时,只存在长度为1的不下降序列;

若从b(n-1)开始查找,则存在下面的两种可能性:

①若b(n-1)<b(n)则存在长度为2的不下降序列b(n-1),b(n)。

②若b(n-1)>b(n)则存在长度为1的不下降序列b(n-1)或b(n)。

一般若从b(i)开始,此时最长不下降序列应该按下列方法求出:

在b(i+1),b(i+2),…,b(n)中,找出一个比b(i)大的且最长的不下降序列,作为它的后继。

(3)代码

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public class LongSubSequence {
 /**
 * 最长不下降子序列
 * 逆序
 * 含义:f[n]-从n到最后的最大长度;c[n]-存放下一个的下标
 * 公式:f[n] = max{f[x]} + 1;{x>n && a[n]<=a[x]}
 * 边界:f[a.length-1] = 1;
 * */
 public void negative(int[] a) {
 int length = a.length;
 int[] f = new int[length];
 int[] c = new int[length];
 // border
 f[length-1] = 1;
 // formula
 int i,j;
 for (i=length-2; i>=0; i--) {
 // 保存长度
 int l = 0;
 // 保存索引
 int k = 0;
 for (j=i+1; j<=length-1; j++) {
 if (l<f[j] && a[i]<=a[j]) {
 l = f[j];
 k = j;
 }
 }
 f[i] = l + 1;
 c[i] = k;
 }
 // result
 int temp = 0;
 int index = 0;
 for (i=0; i<length; i++) {
 if (temp < f[i]) {
 temp = f[i];
 index = i;
 }
 }
 System.out.println("the long of sub sequence : " + temp);
 System.out.print("the sub sequence is : ");
 while (index != 0) {
 System.out.print(a[index] + " ");
 index = c[index];
 }
 }
 /**
 * 最长不下降子序列
 * 正序
 * 含义:f[n],从起点到当前的最大长度
 * 公式:f[n] = max{f[x]} + 1;{0<=x<n && a[x]<=a[n]}
 * 边界:f[0] = 1;
 * */
 public void positive(int[] a) {
 int length = a.length;
 int[] f = new int[length];
 int[] c = new int[length];
 // border
 f[0] = 1;
 // formula
 int i,j,l,k;
 for (i=1; i<length; i++) {
 l = 0;
 k = 0;
 for (j=0; j<i; j++) {
 if (l<f[j] && a[j]<=a[i]) {
 l = f[j];
 k = j;
 }
 }
 f[i] = l + 1;
 c[i] = k;
 }
 // result
 int temp = 0;
 k = 0;
 for (i=0; i<length; i++) {
 if (temp < f[i]) {
 temp = f[i];
 k = i;
 }
 }
 System.out.println("the long of sub sequence : " + temp);
 System.out.print("the sub sequence is : ");
 while (k != 0) {
 System.out.print(a[k] + " ");
 k = c[k];
 }
 }
 public static void main(String[] args) {
 LongSubSequence l = new LongSubSequence();
 int[] a = new int[]{13,7,9,16,38,24,37,18,44,19,21,22,63,15};
 l.negative(a);
 System.out.println("");
 l.positive(a);
 }
}
</pre>

2.3 走楼梯

(1)问题描述

有 n 级台阶,一个人每次上一级或者两级,问有多少种走完 n 级台阶的方法

(2)解析

本质上是斐波那契数列问题

假设只有一个台阶,那么只有一种跳法,那就是一次跳一级,f (1)=1;如果有两个台阶,那么有两种跳法,第一种跳法是一次跳一级,第二种跳法是一次跳两级,f (2)=2。如果有大于 2 级的 n 级台阶,那么假如第一次跳一级台阶,剩下还有 n-1 级台阶,有 f (n-1) 种跳法,假如第一次条 2 级台阶,剩下 n-2 级台阶,有 f (n-2) 种跳法。这就表示 f (n)=f (n-1)+f (n-2)

(3)代码

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">/**
 * 有 n 级台阶,一个人每次上一级或者两级,问有多少种走完 n 级台阶的方法
 * 含义:f[n]-走法个数
 * 公式:f[n] = f[n-1] + f[n-2]
 * 公式代表第一步走一阶,则有f[n-1],第一步走二阶,则有f[n-2]
 * */
 public int positive(int n) {
 if (n == 1) {
 return 1;
 } else if (n == 2) {
 return 2;
 } else {
 int[] f = new int[n+1];
 f[1] = 1;
 f[2] = 2;
 for (int i = 3; i<=n; i++) {
 f[i] = f[i-1] + f[i-2];
 }
 return f[n];
 }
 }
</pre>

2.4 公共子序列

(1)问题描述

一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说,若给定序列X=<x1,x2,…,xm>,则另一序列Z=<z1,z2,…,zk>是X的子序列是指存在一个严格递增的下标序列<i1,i2,…,ik>,使得对于所有j=1,2,…,k有:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">Xij=Zj
</pre>

例如,序列Z=<B,C,D,B>是序列X=<A,B,C,B,D,A,B>的子序列,相应的递增下标序列为<2,3,5,7>。给定两个序列X和Y,当另一序列Z既是X的子序列又是Y的子序列时,称Z是序列X和Y的公共子序列。例如,若X=<A,B,C,B,D,A,B>和Y=<B,D,C,A,B,A>,则序列<B,C,A>是X和Y的一个公共子序列,序列 <B,C,B,A>也是X和Y的一个公共子序列。而且,后者是X和Y的一个最长公共子序列.因为X和Y没有长度大于4的公共子序列。

给定两个序列X=<x1,x2,…,xm>和Y=<y1,y2….yn>.要求找出X和Y的一个最长公共子序列。

(2)样例输入

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">ABCBDAB
BDCABA
</pre>

(3)样例输出

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">4
</pre>

(4)代码

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">/**
 * @author 谢世杰
 */
public class LongCommonSequence {
 /**
 * 顺序
 * 两个序列的最长公共子序列
 *
 * 含义:f[x][y],A序列0...x 和 B序列0...y 的公共子序列最大长度
 *
 * 分四种情况考虑:
 * 1.A[x]在公共子序列,B[y]不在,则f[x][y] = f[x][y-1]
 * 2.A[x]不在公共子序列,B[y]在,则f[x][y] = f[x-1][y]
 * 3.A[x],B[y]均在,则f[x][y] = f[x-1][y-1] + 1
 * 4.A[x],B[y]均不在,则f[x][y] = f[x-1][y-1]
 * 则 f[x][y] 取上述最大值即可,f[x-1][y-1]和f[x-1][y-1]+1 可以合并为后者
 *
 * 公式:f[x][y] = max{f[x][y-1],f[x-1][y],f[x-1][y-1]+1}
 * 边界:f[0...x][0] = 0, f[0][0...y] = 0
 * */
 public void method(char[] a, char[] b) {
 int na = a.length;
 int nb = b.length;
 int[][] f = new int[na+1][nb+1];
 // 公式
 int i,j;
 for (i=1; i<=na; i++) {
 for (j=1; j<=nb; j++) {
 // 考虑a,b中有一个是在目标子串中
 f[i][j] = f[i-1][j] > f[i][j-1] ? f[i-1][j] : f[i][j-1];
 // 当a,b都在目标子串中
 if (a[i-1] == b[j-1]) {
 f[i][j] = (f[i-1][j-1] + 1) > f[i][j] ? (f[i-1][j-1] + 1) : f[i][j];
 }
 }
 }
 System.out.println("long = " + f[na][nb]);
 }
 public static void main(String[] args) {
 LongCommonSequence l = new LongCommonSequence();
 String a = "ABCBDAB";
 char[] aa = a.toCharArray();
 String b = "BDCABA";
 char[] bb = b.toCharArray();
 l.method(aa,bb);
 }
}
</pre>

看到这里的朋友们,还有更多的读者福利哦~除了上面分享的66个Java面试知识点,小编在这里还要分享一下Java架构专题的面试资料及一些大厂的面试资料,还有更多的Java架构学习资料哦(高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码,MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料)

1、Java架构专题面试

(Java,spring,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx...)

2、大厂面试

(BAT,天猫,蚂蚁,中兴,迅雷,网易,华为,谷歌......)

3、Java架构学习资料(笔记+视频)

Java实现动态规划经典题目 动态规划入门请看: DP动态规划专题(一)动态规划基本模型 前言 【说明】 关于动态规划的见解:动规和递归有很多相似的地方,最显著的特征可以说是阶段性,二者都有很明显的阶段划分,所以,声明好每一个阶段所需要做的事情以及阶段与阶段之间的转移可以说是重中之重了,这就涉及几个问题,第一,需要声明好方法(递归)或者数组(动规)具体的意义,所代表的作用;第二,需要说明好递归处理数据的方式(递归)或者是阶... 阅读详情

相关推荐

ImageNet分类实战:用PyTorch复现AlexNet的5个关键技巧(附代码)

本文详细介绍了使用PyTorch复现经典AlexNet模型进行ImageNet图像分类的五个关键工程技巧。内容涵盖模型架构的现代重构、训练策略优化、核心组件实现与替代方案,以及实用的训练调试方法,并提供了完整的代码示例,帮助开发者深入理解深度卷积神经网络的实现细节与优化思路。

i0j1k2l3m的博客 95

[java] 动态规划专题

一、线型动态规划 1.1、单串问题 1.1.1、最经典单串LIS系列 题目:300. 最长递增子序列 给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 解析 定义dp[i]dp[i]dp[i] 为考虑前 i 个元素,以第 i 个数字结尾的最长上升子序列的长度,注意 nums[i]nums[i]nums[i] 必须被选取。 我们从小到大

浅夜 288

混合整数规划(MIP)在资源优化中的实战应用

本文深入探讨了混合整数规划(MIP)在资源优化中的实战应用,从菜市场采购到工厂调度,再到物流配送和钢铁厂切割问题。通过分支定界法和割平面法等技术,MIP能够有效解决包含整数和连续变量的复杂优化问题,提升企业运营效率。文章还介绍了现代求解器的优化策略和实际项目中的避坑指南,帮助读者更好地应用MIP技术。

weixin_30500105的博客 91

Java编程题:动态规划(汇总)

动态规划(Dynamic Programming) 动态规划是分治思想的延伸,通俗一点来说就是一种大事化小,小事化无的艺术。在将大问题化解为小问题的分治过程中,保存对这些小问题已经处理好的结果,并供后面处理大问题时直接使用这些结果。 动态规划具备了以下三个特点 把原来的问题分解成了几个相似的子问题。 所有的子问题都只需要解决一次。 储存子问题的解。 动态规划的本质是对问题状态的定义和状态转移方程的定义(状态以及状态之间的递推关系)。 动态规划问题的求解步骤: 状态定义 状态间的转移方程定义 状态的初始

长不大的大灰狼 1366

CANFD升级踩坑实录:DBC转换时DLC大于8的信号怎么处理?

本文详细探讨了CANFD升级过程中DLC大于8的信号处理问题,提供了工程化解决方案和AutoSar BSW层配置要点。通过分析CAN与CANFD的DLC本质差异,提出信号拆分重组、DLC重映射和协议层适配三种策略,并给出验证与测试方案,帮助开发者避免数据截断和通信故障。

weixin_42521843的博客 233

反卷积通俗详细解析与nn.ConvTranspose2d重要参数解释

反卷积的作用 卷积中padding的几个概念 No Padding Half(Same) Padding Full Padding 反卷积 反卷积中的Padding参数 反卷积的stride参数 反卷积总结 参考资料

iioSnail的博客 2万+

算法与数据结构——动态规划(java)(b站左程云课程笔记总结)

算法与数据结构——动态规划(Java)

Borslav的博客 1058

第16课:动手实战中文句法依存分析

句法分析是自然语言处理(NLP)中的关键技术之一,其基本任务是确定句子的句法结构或者句子中词汇之间的依存关系。主要包括两方面的内容:一是确定语言的语法体系,即对语言中合法句子的语法结构给予形式化的定义;另一方面是句法分析技术,即根据给定的语法体系,自动推导出句子的句法结构,分析句子所包含的句法单位和这些句法单位之间的关系。 句法分析被用在很多场景中,比如搜索引擎用户日志分析和关键词识别,比如信息抽...

春华秋实 2438

动态规划(Java)

动态规划的目的就是避免重复计算,在暴力递归的过程中若在计算过程中产生了重复计算那么就可以进行动态规划的优化。以空间换时间,可以根据暴力递归的过程写出动态规划的过程。步骤: 题 -> 找到暴力递归算法 -> 有重复解 -> 找打可变参数 -> 记忆化搜索 -> 精细化组织变为经典的动态规划算法什么暴力递归可以继续优化?有重复调用同一个子问题的解,这种递归可以优化,如果每一个子问题都是不同的解,无法优化也不用优化面试中设计暴力递归过程的原则每一个可变参数的类型、一定不要比int类型更加复杂。

weixin_45036949的博客 3288

[QMT量化交易小白入门]-三十七、QMT中如何使用类似于通达信中的VBA函数(量化python代码解析)

这段代码主要围绕着在QMT环境中实现类似通达信VBA函数的功能展开,核心功能是基于RSI指标来判断股票的买卖时机,并根据持仓情况进行相应的交易操作。class G():passg = G()这里定义了一个空类G,并创建了该类的实例g。这个实例g将作为全局变量来存储一些在整个程序运行过程中需要共享的数据,例如除复权类型、股票代码、目标数量等。1、使用VBA开发策略时,参数固化的问题会带来一些限制,比如无法修改MA函数的周期参数,只能使用固定周期。

木头大左的博客 1702

手把手教你学Simulink实例:基于Simulink的超级电容器充放电仿真

超级电容器(Supercapacitor)是一种高容量电容器,具有快速充放电能力、长寿命和高功率密度等优点。它在能量存储系统、电动汽车、不间断电源(UPS)等领域有广泛应用。为了更好地理解和设计超级电容器的应用系统,通常需要进行详细的仿真分析。Simulink 提供了一个强大的仿真环境,可以用来设计、分析和验证超级电容器充放电系统的控制策略。本教程将详细介绍如何使用 Simulink 进行超级电容器充放电的仿真实例。通过本教程,我们详细介绍了如何使用 Simulink 进行超级电容器充放电的仿真实例。

MHD0815的博客 581

【JAVA】动态规划经典例题

钢条问题 public class 钢条问题 { public static void main(String[] args) { int[] p = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 }; int n = 5;// 钢条长度 int rn = max(n, p); // int[] baks=new int[p.length]; //...

LED_of_Java的博客 549

Unity实战篇 | 教你怎样将Unity的启动Logo 设置成 自己制作的 帧动画

上一篇文章我们讲了怎样在不购买专业版的情况下自定义Unity的启动Logo。 那本篇文章就来介绍一下,怎样在去除默认Logo的前提下制作自己的启动动画!

努力前行,总会成为自己心中的那道光 6万+

动态规划经典例题(java代码实现)

1、斐波那契数列 题目描述: 有一楼梯共M级,刚开始时你在第一级,若每次只能跨上一级或二级,要走上第M级,共有多少种走法? 输入: 输入数据首先包含一个整数N,表示测试实例的个数,然后是N行数据,每行包含一个整数M(1<=M<=40),表示楼梯的级 输出: 对于每个册数用例,请输入不同走法的数量 import java.util.Scanner; public...

xiaolu1014的博客 5083

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

动态规划算法及其经典问题求解(Java)

与之相反,动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题。对于每个数,都有选和不选两种状态,如果选了这个数,那么就不能选他相邻的那个数,那么最大和就等于本身加上他相邻的那位数之前那些数的最大和,如果不选这个数,那么便可以选它相邻的那个数,那么最大和就等于这个数之前的那些数的最大和。将整个问题划分成一个个子问题,也就是说要求整个数列的最大和,可以先求出前面若干个数的和,一直划分到求出只有一个数的最大和(即本身),而每个子问题的解对于后面的结果都是有用的,这就是用到了动态规划的思想。

博客简介 6560

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

动态规划经典例题java实现

动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度,因此它比回溯法、暴力法等要快许多。     解决动态规划问题的关键是要找到状态转移方程。将问题分解成最小的子问题,找到由子问题到全局问题的解决方案。     可以采用动态规划求解的问题的一般要具有3个性质:     (1) 最优化原理:如果问题的最优解所包含

lavender*的博客 7784

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Leetcode上动态规划系列经典题的Java详解

宅家防疫期间leetcode上小刷了十余道线性动态规划算法题,是时候自己总结提炼一下DP思想了。 我把总结的题目主要分为两类序列匹配类和生活类。 第一类的代表热题: leetcode300. 最长上升子序列 leetcode53.最大子序和 leetcode1143. 最长公共子序列 leetcode72. 编辑距离 第二类的代表热题: leetcode121. 买卖股票的最佳时机 leetcod...

我的技术日常 499

java动态规划算法

java动态规划和递归的区别,java动态规划的用法,例题

Azbtt的博客 1005

算法学习 | 动态规划经典练习题合集

动态规划思想~带权值的最小路径和、背包问题(二)、分割回文串-ii、编辑距离

qq_58284486的博客 3584

Java动态规划算法——背包问题,最大子序和问题

(1)用动态规划算法解决背包问题:有一个背包,容量为4,要求达到的目标为装入的背包的总价值最大,并且重量不超出,同时装入的物品不能重复。 (2)用动态规划算法解决最大子序和问题:给你一个整数数组 nums ,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。..................

qq_54836465的博客 886

Java动态规划算法

动态规划是一种非常重要的算法思想,在Java中也有很多应用。本文以最长递增子序列问题为例,介绍了Java中动态规划算法的实现方法。需要注意的是,动态规划算法通常需要使用数组或表格来保存中间结果,因此需要额外的空间来存储中间结果。在实际应用中,我们需要根据具体问题的特点来选择合适的动态规划算法,并对算法的时间复杂度进行分析,以确保算法能够在实际问题中得到有效的应用。

我滴小博客 1412

Java-算法-动态规划-附一

前置条件 动态规划最重要的是转移方程,而转移方程需要递归和记忆化搜索产生的表,因此直接贴出转移方程是没什么用的,不探究如何从递归到记忆化搜索再到转移方程,还是很难想到怎么去得到转移方程。下面我们将从例子中探寻如何三步走。 例四. leetcode62 一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。问总共有多少条不同的路径? (1)........

weixin_45532984的博客 553

java 动态规划例题

动态规划 1、剑指 Offer 10- I. 斐波那契数列 class Solution { public int fib(int n) { if(n == 0) return 0; int[] df = new int[n + 1]; df[0] = 0; df[1] = 1; for(int i = 2; i < n + 1; i++){ df[i] = (df[i - 1] + df[

qq_42594282的博客 533

java算法学习索引之动态规划

第2年a生了新的小母牛,记为b,总牛数为2;第3年a生了新的小母牛,记为c,总牛数为3;第4年a生了新的小母牛,记为d,总牛数为4。第5年b成熟了,a和b分别生了新的小母牛,总牛数为6;第6年c也成熟了,a、b和c分别生了新的小母牛,总牛数为9,返回9。补充问题 2:假设农场中成熟的母牛每年只会生 1 头小母牛,并且永远不会死。第一年农场有1只成熟的母牛,从第二年开始,母牛开始生小母牛。所以有三种走法,返回3。补充问题 1:给定整数 N,代表台阶数,一次可以跨 2个或者 1个台阶,返回有多少种走法。

u014755700的博客 637

Java算法之动态规划

​ 动态规划通常用于求解具有最优子结构特性的问题,即问题的最优解可以由其子问题的最优解有效地构造出来。此外,动态规划还要求子问题空间必须足够小,即子问题的数量随着问题规模的增加不会增长得太快,以便能够用有限的内存和时间来解决。

zzx0419_的博客 2382

动态规划算法详解,Java实现相关例题。

前沿基础: 一)基本理解: 1、动态规划定义:将将原问题拆解为若干个子问题,同时保留子问题的答案,使得每个子问题只求解一次最终得到原问题的答案。 这样一听总感觉和分治算法很像,其实动态规划就是将分治递归算法转化成了非递归形式,减少了系统栈的调用,使用循环来解决问题。 2、动态规划算法的说白了就是找到整个问题的全局最优解,这也是与贪心算法寻找局部最优解的本质区别。 3、通常我们可以先用从顶向下的思考方式来写出递归分治的代码,然后再联想从低向下的思想来转化为动态规划代码. 4、无论是递...

weixin_60414376的博客 4384
上一篇: 开发10年程序员建议:掌握这6点,让你的秋招之路收获更多offer
下一篇: MySQL数据库优化的这几种方式你都知道吗?
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值