目录
1.动态规划概念
一.定义数组元素的含义
二.找到数组元素之间的关系表达式
三.找到初始值
2.案例详解
一:爬楼梯
1.定义数组元素的含义
2.找到数组元素之间的关系表达式
3.找到初始值
案例二:最短路径
题目:
做题步骤:
1.定义数组的含义
2.找到数组元素之间的关系表达式
3.找到初始值
代码展示:
动态规划就是利用历史记录,来避免我们进行重复计算,而这些历史记录,我们需要用一些变量来保存,一般使用一维数组或者二维数组,下面我们来说动态规划最重要的三个步骤:
因为我们需要用一个数组来保存历史数据,那么最重要的来了,需要保存的历史数据是什么?
也就是数组内存放的元素含义是什么?
也就是说,我们可以利用数组中保存的历史数据推理计算出来新的元素值,所以我们要找到数组之间元素的关系表达式,例如dp[n] = dp[n-1] + dp[n-2]这就是一个关系表达式,然而这一步,恰恰是动态规划中最难的一步了
学过数学的人都知道,虽然我们拥有了元素之间的关系表达式,知道了dp[n] = dp[n-1] + dp[n-2],但是我们还得知道初始值啊,不然一直往前推,推到不能再分解的时候,我们不知到初始元素的值,怎么计算所有的元素值呢?
拥有了初始值,也拥有了数组之间的关系式,我们就可以计算出dp[n]的值了,dp[n]的值是由我们自己来定义的,我们想求得什么,我们就定义什么,这样就能解出题了
假设你正在爬楼梯。需要 n
阶你才能到达楼顶。
每次你可以爬 1
或 2
个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2 输出:2 解释:有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶
示例 2:
输入:n = 3 输出:3 解释:有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶
首先我们来定义dp[i]的含义,既然我们要算出爬上楼顶需要多少种不同的方法,那么我们就可以定义dp[i]为爬到第i曾一共需要多少种方法?这样我们算出dp[i]就等于算出了最终的结果
动态规划就是把一个大问题不停的分解成子问题,然后由子问题推导出大问题,这道题我们需要求的是dp[n],那么我们需要寻找dp[n]与历史数据之间的关系
这也是最最最难的一步:
这道题我们在爬楼梯时可以选择爬一级,也可以选择爬两级,所以我们爬到楼顶时有两种方式,
一种是从n-1级爬上来
一种时从n-2级爬上来
所以可得关系表达式为:dp[n] = dp[n-1] + dp[n-2]
这道题我们可以直观地看出dp[0] = 1,dp[1] = 1;
现在我们可以来写代码了:
public int climbStairs(int n) {
int [] dp = new int[n + 1];
dp[0] = 1;
dp[1] = 1;
for(int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
大部分动态规划都是需要用二维数组来解答的,所以这部分也格外重要
给定一个包含非负整数的 m x n
网格 grid
,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。
说明:每次只能向下或者向右移动一步。
示例 1:
输入:grid = [[1,3,1],[1,5,1],[4,2,1]] 输出:7 解释:因为路径 1→3→1→1→1 的总和最小。
提示:
m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 100
求什么就怎么定义,所以我们定义数组dp[i][j]为当从左上角走到(i,j)这个位置时的最短路径,那么dp[m-1][n-1]就是我们所要求的答案
由于题目中表示,每次只能向下或者向右移动一步,
第一种情况:当我们所处位置在上边界或者左边界时,我们只有一个方向的路可以选择,
此时状态转移方程为:
1.处于上边界 i = 0时 dp[i][j] = dp[i][j-1] + grid[i][j]
2.处于左边界 j = 0时 dp[i][j] = dp[i-1][j] + grid[i][j]
第二种情况既不处于左边界又不处于上边界
一共有两种方式可以到达(i,j)这个位置,
一种是从(i-1)(j)向右走一步到达
一种是从(i)(j-1)向下走一步到达
我们需要计算最短路径,所以关系式为 dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i][j]
此题的初始值即为dp[0][0] = grid[0][0]
public int minPathSum(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
int [][] dp = new int[m][n];
dp[0][0] = grid[0][0];
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
if(i == 0 && j == 0) {
continue;
} else if (i == 0) {
dp[i][j] = dp[i][j-1] + grid[i][j];
} else if(j == 0) {
dp[i][j] = dp[i-1][j] + grid[i][j];
} else {
dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + grid[i][j];
}
}
}
return dp[m-1][n-1];
}
学习并非一朝一夕的事情,所以即使我们懂得了动态规划的原理,但还是需要日复一日的刷题,最终才能量变引起质变,达到熟练的效果