动态规划:
题目分为五大部分:基础问题、背包问题、打家劫舍、股票问题、子序列问题
解题五部曲:
- 确定dp数组(dp table)以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
思路:
dp[i] 表示第i个数的斐波那契数值大小,递推公式dp[i] = dp[i - 1] + dp[i - 2],初始化dp[0] = 0,dp[1] = 1,遍历顺序从前往后,因为后面的数需要根据前面的数之和才能得到。
代码:
class Solution {
public:
int fib(int n) {
if(n == 0 || n == 1) return n;
//dp[i] 第i个数的斐波那契数值
vector<int> dp(n + 1);
//dp初始化
dp[0] = 0;
dp[1] = 1;
for(int i = 2; i <= n; i++){
dp[i] = dp[i - 1] + dp[i - 2]; //dp递推公式
}
return dp[n];
}
};
思路:
dp[i]表示爬到第i层楼梯的方法数,题目明确一次可以爬 1个或者2个阶梯,那么爬到第i - 1层楼梯再爬1个阶梯就到了第i层或者爬到第i - 2层楼梯再爬2个阶梯就到了第i层,因此dp递推公式
就是dp[i] = dp[i - 1] + dp[i - 2],表示爬到第i层楼梯的方法数等于爬到第i -1层楼梯的方法数加上爬到第i - 2层楼梯的方法数。
代码:
class Solution {
public:
int climbStairs(int n) {
//dp[i]含义:爬到第i层楼梯的方法数
vector<int> dp(n + 1);
if(n <= 2) return n;
//dp初始化
dp[1] = 1;
dp[2] = 2;
for(int i = 3; i <= n; i++){
dp[i] = dp[i - 1] + dp[i - 2];//dp递推公式
}
return dp[n];
}
};
//时间复杂度:O(n)
//空间复杂度:O(n)
优化:空间复杂度O(n)优化成O(1)
class Solution {
public:
int climbStairs(int n) {
//dp[i]含义:爬到第i层楼梯的方法数
vector<int> dp(n + 1);
if(n <= 2) return n;
//dp初始化
dp[1] = 1;
dp[2] = 2;
for(int i = 3; i <= n; i++){
//状态转移
int sum = dp[1] + dp[2];
dp[1] = dp[2];
dp[2] = sum;
}
return dp[2];
}
};
//时间复杂度:O(n)
//空间复杂度:O(1)
题目:746. 使用最小花费爬楼梯 - 力扣(LeetCode)
思路:注意本题题意,如果楼梯阶层是n,爬到楼顶是指爬到n + 1层,因此 i = cost.size()
dp[i] 表示爬到第i层的最小花费。题目说可以爬一层或两层,那么爬到第i层的最小花费是等于(爬到第i - 1层的最小花费 + 从第 i - 1层爬到i层的花费) 与 (爬到第i - 2层的最小花费 + 从第 i - 2层爬到i层的花费)这两者之间的最小值。
dp递推公式:dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]) dp初始化:dp[0] = 0, dp[1] = 0,题目明确可以从第0层或者第1层开始爬,只有往上爬才花费。
代码:
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
vector<int> dp(cost.size() + 1, 0);
dp[0] = 0;
dp[1] = 0;
for(int i = 2; i <= cost.size(); i++){//注意i == cost.size() 因为要爬到楼顶,因此i要比cost数组中的台阶数多一
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[cost.size()];
}
};
思路:
dp[i][j]表示从(0,0)位置走到(i,j)位置路径数总和。
因为只能往右走或者往下走,那么第1行和第1列上的位置路径数都只有一种方法,因此初始化为1。dp递推公式:dp[i][j] = dp[i][j - 1] + dp[i - 1][j],要走到(m,n) 的位置,最后返回dp[m - 1][n - 1]就行。
代码:
class Solution {
public:
int uniquePaths(int m, int n) {
int dp[m][n];
for(int i = 0; i < n; i++){
dp[0][i] = 1;
}
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++){
//(i, j - 1)的位置向右走一步或者(i - 1, j)的位置向下走一步
//走到(i,j)
dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
}
}
return dp[m - 1][n - 1];
}
};
思路:
dp[i][j]表示从(0,0)位置走到(i,j)位置路径数总和。因为只能往右走或者往下走,那么第1行和第1列上的位置路径数都只有一种方法,但是因为可能会有障碍物在第一行或者第一列上,一旦有的话,在第一行或者第一列上的障碍物后的位置都不能到达,dp[i][j]都为0,因此障碍物之前dp都为1,之后都为0。
dp递推公式:dp[i][j] = dp[i][j - 1] + dp[i - 1][j],注意代码里for循环的终止条件,一旦遇到obstacleGrid[i][0] == 1的情况就跳过(等价于将这个位置dp赋值为0),然后继续下一个位置的dp赋值。
代码:
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
vector<vector<int>> dp(m, vector<int>(n, 0));//初始化为0
//如果左上角或者右下角有障碍物,直接返回0
if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;
for(int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for(int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
if(obstacleGrid[i][j] == 1) continue;//如果遇到障碍物需要跳过,等价于dp[i][j] = 0,即到达(i,j)这个点的路径和为0,因为dp已经初始化为0了,所以不需要赋值为0,直接continue
dp[i][j] = dp[i][j - 1] + dp[i - 1][j];//未遇到障碍物直接统计路径和
}
}
return dp[m - 1][n - 1];
}
};