动态规划五步
- 确定dp数组(dp table)以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
一维dp数组
509.斐波那契数列
动态规划:
class Solution {
public int fib(int n) {
int []dp = new int[n+1];
if(n<2){
return n;
}
//初始化dp数组
dp[0] = 0;
dp[1] = 1;
for(int i=2; i<dp.length; i++){
//确定遍历顺序
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
}
递归:
class Solution {
public int fib(int n) {
if(n<2){
return n;
}
return fib(n-1) + fib(n-2);
}
}
70.爬楼梯
class Solution {
public int climbStairs(int n) {
if(n<2){
return n;
}
int[] dp = new int[n+1];
//爬1阶一种方法
dp[1] = 1;
//爬2阶梯二种方法
dp[2] = 2;
for(int i=3; i < dp.length; i++){
//遍历顺序:从第n-1阶台阶爬1级或从n-2阶台阶爬2级
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
}
746.使用最小花费爬楼梯
class Solution {
public int minCostClimbingStairs(int[] cost) {
//dp数组含义:到达i位置花费为dp[i]
int[] dp =new int[cost.length+1];
//初始化dp数组,从0和1位置爬都无需花费
dp[0] = 0;
dp[1] = 0;
for(int i=2; i < dp.length; i++){
//dp[i-1]为到达i-1位置需要的花费,dp[i-1]+cost[i-1]为到i位置所需花费
dp[i] = Math.min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]);
}
return dp[cost.length];
}
}
二维dp数组
62.不同路径
class Solution {
public int uniquePaths(int m, int n) {
//dp[m][n]为到达(m,n)的路径数
int[][] dp = new int[m][n];
//初始化dp数组
for(int i=0; i<m; i++){
//到(i,0)只有一种路径
dp[i][0] = 1;
}
for(int i=0; i<n; i++){
//到(0,i)只有一种路径
dp[0][i] = 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];
}
}
数论:
从左上角到右下角的过程中,我们需要移动m+n−2 次,其中有 m−1 次向下移动,n−1 次向右移动。因此路径的总数,就等于从 m+n−2 次移动中选择 m−1 次向下移动的方案数,即组合数:
class Solution {
public int uniquePaths(int m, int n) {
long ans = 1;
for (int x = n, y = 1; y < m; ++x, ++y) {
ans = ans * x / y;
}
return (int) ans;
}
}
63.不同路径
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
int[][] dp = new int[m][n];
//初始化dp数组,到(i,0)和(0,j)位置都只有一种方法,遇到障碍停止
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] = 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];
dp[2] = 1;
for(int i=3; i<=n; i++){
for(int j=1; j<i-1; j++){
//遍历顺序,固定j后,1.i-j与j直接相乘;2.i-j再拆分,j与dp(i-j)相乘
dp[i] = Math.max(Math.max(j*(i-j), j*dp[i-j]), dp[i]);
}
}
return dp[n];
}
}
96.不同的二叉搜索树
class Solution {
public int numTrees(int n) {
int[] dp = new int[n+1];
//初始化dp数组,dp[0]为1
dp[0] = 1;
//递推公式:j-1 为j为头结点左⼦树节点数量,i-j 为以j为头结点右⼦树节点数量
for(int i=1; i<=n; i++){
for(int j=1; j<=i; j++){
dp[i] += dp[j-1]*dp[i-j];
}
}
return dp[n];
}
}