104、4.29-动态规划思路总结-第二周的几道题最难想

一、简单的动态规划

1.斐波那契数列

2.爬楼梯：和斐波那契数列一模一样

class Solution {
    //本题几乎和 斐波那契一样
    public int climbStairs(int n) {
        //1.未优化
        int[] dp = new int[n];
        dp[0] = 1;//在台阶一处,有一种方式
        dp[1] = 2;//两种方式到 n=2处
        for(int i = 2;i < n;i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n - 1];

        //2.优化
        if(n <= 2) return n;
        int dp0 = 1;
        int dp1 = 2;
        int sum = 0;
        for(int i = 2;i < n;i++){
            sum = dp0 + dp1;
            dp0 = dp1;
            dp1 = sum;
        }
        return sum;
    }
}

3.使用最小花费爬楼梯

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n = cost.length;
        int dp0 = 0;
        int dp1 = Math.min(dp0 + cost[1],cost[0]);//站在二台阶上,最小花费；可能是先到1再从一跳到2；也可能是从0出发直接到2
        int sum = 0;
        //模仿前两道的优化方式
        for(int i = 2;i < n;i++){
            sum = Math.min((dp1 + cost[i]),(dp0 + cost[i - 1]));//得到更少的花费
            dp0 = dp1;
            dp1 = sum;
        }
        if(n == 2) return Math.min(cost[0],cost[1]);
        return sum;
    }
}

这三道题属于同一种类型的题目，比较简单！

最基础的思路：声明一个dp数组，将数组每个位置代表的含义确定清楚，按照前面位置的结果进行后续内容的计算！

优化：确定当前状态值和前面哪些状态值有关；可以将空间复杂度降为 O(1)！

二、二维的路径问题：将dp数组声明为二维的，对应每个位置！

1.不同路径

class Solution {
    public int uniquePaths(int m, int n) {
        //使用二维数组，记录到达每个位置，有多少种走法
        //每个位置，只能由左和右，两个位置到达
        int[][] dp = new int[m][n];
        for(int i = 0;i < m;i++){
            for(int j = 0;j < n;j++){
                if(i == 0 || j == 0) dp[i][j] = 1;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

2.不同路径Ⅱ

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        //两个for对边界的处理
        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];
    }

二维的dp数组，处理起来也挺简单。

★★三、双层for循环的动态规划

1.整数拆分：

自己的第一思想是按照分成的数字个数进行状态划分；实际按照要拆分的数进行划分！

n进行拆分，就需要 1 - n之间数组的结果！

一个数字可以拆分成两个数字或者多个数字的乘积！

拆分成两个数字也有多种结果，就需要内层的 for循环，从头开始拆分！

dp[i]表示最大的乘积：① (i - j) * j就是拆分成两个数字的乘积；

                                        ② j * dp[i - j]就是拆分成两个以上数字的乘积；

第一个数字是 j ：(i - j)是另一个数字；dp[i - j]就是将 i - j进行了拆分！其最大的乘积！

最容易理解的代码：

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }
}

2.不同的二叉搜索树：

自己的思想是：新加入的节点肯定是大于的，只能连接在右子树；进行连接和插空处理，无法解决

思路：类似于整数拆分！

需要 n 个节点二叉搜索书个数：每一个值都可以作为根节点！

将每个值作为根节点分别得到的BST数量相加就得到了结果！

1 - n分别作为根节点的情况！需要注意，节点为0是，树的数量为1！

当选出该节点作为根节点时，左右区间的内容分又可以继续生成 BST！

结果就是左子树数量 * 右子树数量！！！ 成为了子问题！

这两道题类似：外层for循环对不同数字的结果进行计算！

                            内层for循环是具体的处理！因为递推关系不是上一周那种简单的关系！

dp[]数组中的下标，既可以理解为数字，也可以理解为数量！

内层for循环也达到了累加的效果！

class Solution {
    //右子树都可以插空！
    public int numTrees(int n) {
        //模仿 整数拆分从一个节点，加到n个
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2;i < n+1;i++){
            for(int j = 1;j <= i;j++){
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
}

这两道题类似：需要做更多的处理！多思考，叙述不清楚