力扣刷题--动态规划法

动态规划法的特点

后一个状态是基于前一个状态推导而来的

动态规划的解题步骤

1. 确定动态规划数组的含义 即dp[i]的含义
2. 确定递推公式
3. 初始化递推公式
4. 确定遍历顺序
5. 举例推导dp数组

力扣的简单题目

1、斐波那契数列 509题

1、dp[i] 表示n=i的时候的斐波那契数
2、推导公式 dp[i] = dp[i-1] + dp[i-2]
3、初始化 dp[0] = 0 dp[1] = 1
4、遍历顺序 从i=2 到 n
5、推导一遍

    public static int fib3(int n){
        if (n == 0){
            return 0;
        }
        if (n == 1){
            return 1;
        }
        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];
    }

需要注意的点在于，创建数组的时候是new int[n+1]，否则使用dp[n]的时候，会出现数组越界的错误

2、爬梯子 70题

1、dp数组的意义 dp[i] 爬到第i层有几种方法
2、dp数组的推导公式 dp[i] = dp[i-1] + dp[i-2]
3、dp数组的初始化 dp[1] = 1,dp[2] =2
4、确定遍历顺序 从第3层开始，一直到n层
5、推导一遍

 public static int climbStairs(int n) {
        if(n==1){
            return 1;
        }
        if(n==2){
            return 2;
        }
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }

3、使用最小花费爬楼梯 746题

1、dp[i] 爬第i层时花费的最小体力
2、推导公式 dp[i] = min{dp[i-1] + cost[i-1] , dp[i-2] + cost[i-2]}
3、初始化 dp[0] = 0 dp[1] = 0
4、顺序 从i = 2 开始 一直到n（数组长度）
5、推导一遍

    public static int minCostClimbingStairs(int[] cost) {
        int n = cost.length;
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 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];
    }

4、不同路径 62题

1、dp[i][j] 表示在(i,j)处的时候 有多少种方法
2、推导公式 dp[i][j] = dp[i-1][j] + dp[i][j-1]
3、初始化 dp[0][0] = 0 dp[i-1][0] = 1（因为只能向下走） dp[0][j-1] = 1（因为只能向右走）
4、遍历顺序 i: 0–>m j:0–>n
5、推导一遍

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