代码随想录 | 动态规划（1）-优快云博客

class Solution {
    public int fib(int n) {
        if(n <= 1) return n;
        int dp[] = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2; i <= n; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

按照五个步骤依次进行，芜湖起飞！

70. 爬楼梯

70. 爬楼梯 - 力扣（LeetCode）

带你学透动态规划-爬楼梯（对应力扣70.爬楼梯）| 动态规划经典入门题目_哔哩哔哩_bilibili

class Solution {
    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];
    }
}

746. 使用最小花费爬楼梯

746. 使用最小花费爬楼梯 - 力扣（LeetCode）

动态规划开更了！| LeetCode：746. 使用最小花费爬楼梯_哔哩哔哩_bilibili

注意是台阶顶部，而不是最上方的台阶。

import java.lang.Math.*;

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int height = cost.length;
        int[] dp = new int[height + 1];
        dp[0] = 0;
        dp[1] = 0;
        for(int i=2;i<=height;i++){
            dp[i] = Math.min((dp[i-1]+cost[i-1]),(dp[i-2]+cost[i-2]));
        }
        return dp[height];
    }
}

62.不同路径

62. 不同路径 - 力扣（LeetCode）

动态规划中如何初始化很重要！| LeetCode：62.不同路径_哔哩哔哩_bilibili

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for(int i = 0;i < m;i++){
            dp[i][0] = 1;
        }
        for(int i = 0;i < n;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];
    }
}

63. 不同路径 II

63. 不同路径 II - 力扣（LeetCode）

动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        for(int i = 0;i < m;i++){
            if(obstacleGrid[i][0] == 0){
                dp[i][0] = 1;
            }else{
                break;
            }
        }
        for(int j = 0;j < n;j++){
            if(obstacleGrid[0][j] == 0){
                dp[0][j] = 1;
            }else{
                break;
            }
        }
        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];
    }
}

注意语法

在 Java 中，二维数组 int[][] 的尺寸（行数和列数）可以通过以下方式获取，类似于一维数组的 length 方法：

1. 获取二维数组的行数

行数 = 二维数组本身的 length。
语法：obstacleGrid.length（直接访问外层数组的长度）。

int rows = obstacleGrid.length;

2. 获取二维数组的列数

列数 = 二维数组中某一行（例如第一行）的 length。
语法：obstacleGrid[0].length（假设第一行存在且所有行的长度一致）。

// 先检查数组非空且至少有一行
if (obstacleGrid != null && obstacleGrid.length > 0) {
    int cols = obstacleGrid[0].length;
}

在 Java 中，使用 int[][] dp = new int[m][n]; 初始化二维数组后，所有元素会被自动初始化为 0（基本类型 int 的默认值），而非 null。以下是详细解释：

1. 数组初始化规则

基本类型数组（如 int[]、double[]）：所有元素默认值为该类型的零值。
- int → 0
- double → 0.0
- boolean → false
对象类型数组（如 Integer[]、String[]）：所有元素默认值为 null。

2. 二维数组的初始化

外层数组（int[][]）：每个元素是一个 int[] 类型的一维数组。
内层数组（int[]）：每个元素是 int 类型的基本值。

当通过 new int[m][n] 初始化时：

外层数组的每个元素会被初始化为一个长度为 n 的 int[] 数组。
每个内层数组的所有元素会被初始化为 0。

343. 整数拆分

343. 整数拆分 - 力扣（LeetCode）

动态规划，本题关键在于理解递推公式！| LeetCode：343. 整数拆分_哔哩哔哩_bilibili

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n+1];
        dp[1] = 1;
        for(int i=2; i<=n; i++){
            for(int j=1; j<=i/2; j++){
                // 注意每次循环取原先值和此次循环结果的最大值
                dp[i] = Math.max(Math.max((dp[i-j]*j),((i-j)*j)),dp[i]);
            }
        }
        return dp[n];
    }
}

其实可以从1遍历j，然后有两种渠道得到dp[i].