简述
动态规划与贪心
贪心：每次都选择局部最优解
动态规划：每个状态都是由前一个状态推导得到
动态规划解题步骤
- 确定
dp数组 及下标的含义确定递推公式
dp数组 初始化确定遍历顺序
LeeCode 509：斐波那契数
题目描述
斐波那契数（通常使用
F(n)表示）形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。即 \(F(0) = 0;F(1) = 1; F(n) = F(n - 1) + F(n - 2) \quad n > 1\)。给定n，请计算F(n)。
建立模型
确定dp数组及下标的含义, 这里省略了dp数组(当前状态只和前两个状态有关), 借用两个参数a, b来代替. 数组的含义为 F(i)
确定递推公式, dp[i] = dp[i - 1] + dp[i - 2] 即 res = a + b
dp数组初始化, dp[0] = 0, dp[1] = 1 即 a = 0, b = 1
确定遍历顺序, 2 ~ n顺序遍历
代码实现
public int fib(int n) {
if (n <= 1) {
return n;
}
int a = 0, b = 1;
int res = 1;
for (int i = 2; i <= n; i++) {
res = a + b;
a = b;
b = res;
}
return res;
}
LeeCode 70：爬楼梯
题目描述
假设你正在爬楼梯，需要
n阶你才能到达楼顶。每次你可以爬1或2个台阶。你有多少种不同的方法可以爬到楼顶呢？
建立模型
此题与斐波那契数列属于同一题, 不过此次笔者没有省略 dp数组.
确定dp数组及下标的含义, 数组的含义为爬到第 i 阶楼梯的方法数
确定递推公式 dp[i] = dp[i - 1] + dp[i - 2]
dp数组初始化, dp[1] = 1, dp[2] = 2
确定遍历顺序, 3~n 顺序遍历
代码实现
public int climbStairs(int n) {
if (n <= 2) {
return n;
}
int[] dp = new int[n + 1];
// dp数组初始化
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i < dp.length; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
LeeCode 746：使用最小花费爬楼梯
题目描述
给你一个整数数组
cost，其中cost[i]是从第i个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为
0或 下标为1的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。
建立模型
确定dp数组及下标的含义, 数组的含义为到达第 i 个台阶的最小花费
确定递推公式 dp[i] = Math.min(dp[i - 1] + dp[i - 2]) + cost[i]
初始化dp数组, dp[0] = cost[0], dp[1] = cost[1]
确定遍历顺序, 从 2~n 顺序遍历
代码实现
public int minCostClimbingStairs(int[] cost) {
if (cost.length == 2) {
return Math.min(cost[0], cost[1]);
}
int[] dp = new int[cost.length];
dp[0] = cost[0];
dp[1] = cost[1];
for (int i = 2; i < dp.length; i++) {
/**
* 递推数组
* 爬到第 i 阶楼梯的方式包括 从 i - 1 阶爬一个台阶 和 从 i - 2 阶爬两个台阶
* 取其中的花费较小者
*/
dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
}
/**
* 到达顶部的花费选择 倒数第一个台阶和倒数第二个台阶的较小者
*/
return Math.min(dp[cost.length - 1], dp[cost.length - 2]);
}
LeeCode 62：不同路径
题目描述
一个机器人位于一个
m x n网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
建立模型
确定dp数组及下标含义, 数组的含义为到达第i行第j列的路径总数
确定递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
初始化dp数组, 第0行和第0列全都初始化为1
确定遍历顺序, 外循环从左至右, 内循环从上至下
代码实现
public int uniquePaths(int m, int n) {
int[][] dp = new int[m][n];
// dp数组初始化
// 第 0 行初始化
for (int i = 0; i < n; i++) {
dp[0][i] = 1;
}
// 第 0 列初始化
for (int j = 0; j < m; j++) {
dp[j][0] = 1;
}
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
LeeCode 63：不同路径II
题目描述
一个机器人位于一个
m x n网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
建立模型
确定dp数组及下标的含义, 数组的含义为到达第i行第j列的路径总数
确定递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1], 对于网格中的障碍物有dp[i][j] = 0
初始化dp数组, dp[0][0]根据是否有障碍物初始化为0或1, 对于第0行, 则根据左边是否有障碍物初始化为0或1, 第0列则根据上边是否有障碍无初始化为0或1
确定遍历顺序, 外循环从左至右, 内循环从上至下
代码实现
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
int[][] dp = new int[m][n];
// dp数组初始化
if (obstacleGrid[0][0] == 1) {
dp[0][0] = 0;
}
else {
dp[0][0] = 1;
}
// 第 0 行初始化
for (int i = 1; i < n; i++) {
if (obstacleGrid[0][i] == 1) {
dp[0][i] = 0;
}
else {
dp[0][i] = dp[0][i - 1];
}
}
// 第 0 列初始化
for (int j = 1; j < m; j++) {
if (obstacleGrid[j][0] == 1) {
dp[j][0] = 0;
}
else {
dp[j][0] = dp[j - 1][0];
}
}
// 遍历dp数组
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) {
dp[i][j] = 0;
}
else {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
}
return dp[m - 1][n - 1];
}
LeeCode 343：整数拆分
题目描述
给定一个正整数
n，将其拆分为k个 正整数 的和（k >= 2），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。
建立模型
确定dp数组及下标的含义, 数组的含义为 i 可拆分成的乘积最大值
确定递推公式 dp[i] = MAX(Math.max(j * (i - j), j * dp[i - j])) (1 <= j < i)
初始化dp数组, 全都初始化为0
确定遍历顺序, i -> 2~n, j -> 1~(i-1)
代码实现
public int integerBreak(int n) {
int[] dp = new int[n + 1];
for (int i = 2; i <= n; i++) {
int max_value = 0;
for (int j = 1; j < i; j++) {
/**
* j * (i - j) 表示 (i - j) 不继续拆分的乘积值
* j * dp[i - j] 表示 (i - j) 继续拆分的乘积值
*/
max_value = Math.max(max_value, Math.max(j * (i - j), j * dp[i - j]));
}
dp[i] = max_value;
}
return dp[n];
}
LeeCode 96：不同的二叉搜索树
题目描述
给你一个整数
n，求恰由n个节点组成且节点值从1到n互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
建立模型
确实dp数组及其下标的含义, 数组的含义为 i 个节点能构成的不同的二叉搜索树
初始化dp数组, dp[0] = dp[1] = 1, 空树或单节点的树只有一种
确定递推公式, dp[i] += dp[j] * dp[i - j - 1], 该公式的意思为依次遍历每个
数字将其作为根节点, 将 1~j-1 作为左子树, j+1~i 作为右子树, 同时左右子树也
需要满足是二叉搜索树, 且由于根值不同, 可以保证每棵二叉搜索树都是不同的, 所以
该问题就转化成了两个规模更小的问题。
确定遍历顺序, i -> 2~n, j -> 1~i
代码实现
public int numTrees(int n) {
int[] dp = new int[n + 1];
// dp数组初始化
dp[0] = 1;
dp[1] = 1;
// 遍历数组
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i] += dp[j - 1] * dp[i - j];
}
}
return dp[n];
}
