动态规划及其应用（1）

动态规划五部曲：
1.明确动态规划数组(dp)的下标及其元素的含义；
2.明确动态规划数组元素之间的递推关系；
3.明确动态规划数组的初始值；
4.明确遍历顺序(从前往后或从后往前)；
5.打印动态规划数组，以便检查代码逻辑是否正确。
动态规划理论基础：代码随想录

leetcode 509 斐波那契数

class Solution {
    public int[] dp = new int[31];
    public int fib(int n) {
        //初始化数组
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

leetcode 70 爬楼梯

class Solution {
    public int climbStairs(int n) {
        //定义dp数组的下标为到楼顶的层数，dp数组的元素为方法总数
        if(n == 1){
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[0] = 0;
        //初始化dp
        dp[1] = 1;
        dp[2] = 2;
        //确定递推关系与遍历顺序
        for(int i = 3; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

leetcode 746 使用最小花费爬楼梯

class Solution {
    public int min(int val1, int val2){
        return val1 > val2 ? val2 : val1;
    }
    public int minCostClimbingStairs(int[] cost) {
        //定义dp的含义：到达i位置的花销为dp[i]
        //初始化dp数组
        int[] dp = new int[cost.length + 1];
        dp[1] = 0;
        dp[2] = min(cost[0], cost[1]);
        for(int i = 3; i <= cost.length; i++){
            //确定递推关系和遍历顺序（注意使用一次爬两层时需要加上起始位置的花销即：cost[i - 2]）
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[cost.length];

    }
}

leetcode 62 不同路径

本题用到的dp数组是二维数组。

class Solution {
    public int uniquePaths(int m, int n) {
        //定义dp数组的含义：从start位置到（m, n）总共有dp[m][n]种不同的路径
        int[][] dp = new int[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++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

leetcode 63 不同路径（2）

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //用没有障碍物的总路径之和减去到达障碍物的总路径之和
        //定义dp
        int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
        //初始化dp
        //若遇见障碍，则障碍后面的路径一定是0
        for(int i = 0; i < obstacleGrid[0].length && obstacleGrid[0][i] == 0; i++){
            dp[0][i] = 1;
        }
        for(int i = 0; i < obstacleGrid.length && obstacleGrid[i][0] == 0; i++){
            dp[i][0] = 1;
        }
        //确定递推关系与遍历顺序
        for(int i = 1; i < obstacleGrid.length; i++){
            for(int j = 1; j < obstacleGrid[0].length; j++){
                //只在没有遇到障碍的时候递推
                if(obstacleGrid[i][j] != 1){
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
                }
            }
        }
        //结果
        return dp[obstacleGrid.length - 1][obstacleGrid[0].length - 1];
    }
}

leetcode 343 整数拆分

要想将一个数拆分成各个整数并使其乘积最大，则应该数值近似相等的数越多越好。
递推公式：j * dp[i - j]。因为dp数组的含义是拆分i所能够得到的最大值，所以固定j的所有拆分情况中的最大值就是 j * dp[i - j]。(j - 1) * dp[i - j + 1] 便已经包含了 j * dp[i - j] 中再拆分j的所有情况。

class Solution {
    public int max(int val1, int val2, int val3){
        int temp = val1 > val2 ? val1 : val2;
        return temp > val3 ? temp : val3;
    }
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        //初始化dp
        dp[0] = 0;
        dp[1] = 0;
        dp[2] = 1;
        //递推
        for(int i = 3; i <=n; i++){
            for(int j = 1; j <= i / 2; j++){
                //因为要尽可能使拆分得到的数相等，当j大于i / 2时，便不会满足此要求
                //j * (i - j)表示拆分成两个数，j * dp[i - j]表示拆分成3及以上的数
                dp[i] = max(j * (i - j), j * dp[i - j], dp[i]);
            }
        }
        return dp[n];
    }
}

leetcode 96 不同的二叉搜索树

class Solution {
    public int numTrees(int n) {
        //定义dp数组,dp[i]是当整数为i时按照题意所能拥有的BST的个数
        int[] dp = new int[n + 1];
        //初始化
        dp[0] = 1;
        //递推公式以及遍历
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= i; j++){
                //从根节点为1起开始遍历，知道根节点为i时结束。最终的结果为依照遍历顺序累加，依据BST的性质，左子树的所有个数一定为dp[j - 1],右子树的所有个数一定是dp[i - j]。因为左子树一定比j小，右子树一定比j大，而所有节点的值均由1到i递增1组成。
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
}