基础理论
动态规划适合有重叠子问题性质的题目。
动态规划中每一个状态一定是由上一个状态推导出来的。
动态规划五步曲
- 确定dp数组(dp table)以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
动态规划debug
- 找问题的最好方式就是把dp数组打印出来,看看究竟是不是按照自己思路推导的!
- 如果打印出来和自己预先模拟推导是一样的,那么就是自己的递归公式、初始化或者遍历顺序有问题了。
- 如果和自己预先模拟推导的不一样,那么就是代码实现细节有问题。
刷题顺序
基础题目
70. 爬楼梯
class Solution {
public int climbStairs(int n) {
// dp[i]: 爬到第i阶有几种爬法
int[] dp = new int[n+1];
// 初始化
dp[0] = 1;
if(n == 0){
return dp[n];
}
dp[1] = 1;
// 递推公式
for(int i=2; i<=n; i++){
dp[i] = dp[i-1] + dp[i-2];
}
// 返回结果
return dp[n];
}
}
746. 使用最小花费爬楼梯
class Solution {
public int minCostClimbingStairs(int[] cost) {
int n = cost.length; // 台阶下标: 0->n
// dp[i]: 爬到第i级台阶所需的最小费用
int[] dp = new int[n+1];
// 初始化
dp[0] = 0;
dp[1] = 0; // min{cost[0], 0}
// 递推计算
for(int i=2; i<=n; i++){
dp[i] = Math.min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);
}
// 返回结果
return dp[n]; // 楼顶相当于第n+1级台阶
}
}
62. 不同路径
class Solution {
public int uniquePaths(int m, int n) {
// dp[i][j]:从map[0][0]到map[i][j]有多少条不同的路径
int[][] dp = new int[m][n];
// 初始化
for(int j=0; j<n; j++){
dp[0][j] = 1;
}
for(int i=0; i<m; i++){
dp[i][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];
}
}
63. 不同路径 II
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length, n = obstacleGrid[0].length;
// dp[i][j]:从map[0][0]到map[i][j]有多少条不同的路径
int[][] dp = new int[m][n];
// 初始化
boolean flag = false; // 第一个障碍物之后的位置可达路径均为0
for(int j=0; j<n; j++){
if(flag == false){
if(obstacleGrid[0][j] == 0){
dp[0][j] = 1;
}else{
// 第一次遇到障碍物
flag = true;
dp[0][j] = 0;
}
}else{
dp[0][j] = 0;
}
}
flag = false;
for(int i=0; i<m; i++){
if(flag == false){
if(obstacleGrid[i][0] == 0){
dp[i][0] = 1;
}else{
// 第一次遇到障碍物
flag = true;
dp[i][0] = 0;
}
}else{
dp[i][0] = 0;
}
}
// 递推计算
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];
}
}
343. 整数拆分
class Solution {
public int integerBreak(int n) {
// dp[i]: 将正整数i拆分成至少两个正整数的和之后,得到的最大乘积
int[] dp = new int[n+1];
// 初始化:0和1都无法拆分成至少两个正整数的和
dp[0] = dp[1] = 1;
// 递推计算
for(int i=2; i<=n; i++){
// 先从dp[i]中拆分出一个正整数k(1<=k<i)
// 对于剩下的i-k,可以不拆分:k*(i-k),也可以继续拆分成两个正整数之和:k*dp[i-k]
dp[i] = 0;
for(int k=1; k<i; k++){
dp[i] = Math.max(Math.max(k*(i-k), k*dp[i-k]), dp[i]);
}
}
// 返回结果
return dp[n];
}
}
96. 不同的二叉搜索树
class Solution {
public int numTrees(int n) {
// dp[i]:由节点值从1到n的n个节点组成的二叉搜索树的种数
int[] dp = new int[n+1];
// 初始化:不存在由0个节点组成的二叉搜索树
dp[0] = 1;
// 递推计算
for(int i=1; i<=n; i++){
dp[i] = 0;
for(int k=1; k<=i; k++){
dp[i] += (dp[k-1] * dp[i-k]);
}
}
// 返回结果
return dp[n];
}
}