动态规划复习

动态规划五步

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导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];
    }
}