算法训练||70. 爬楼梯||746. 使用最小花费爬楼梯||62.不同路径||63. 不同路径 II

70. 爬楼梯

思路：这一题问爬到第n层一共有多少种方法？

爬到第1层有1种方法，爬到第二层有2种方法，爬到第三层可以由第1层和第二层的状态推导出来

解出这道题的关键在于爬到第n层的方法等于爬到第n-1层的方法数+n-2层的方法数。

想到这个了我们就可以理所应当的想到动态规划：

动规五部曲：

1.dp[i]及其下标的定义：爬到第i层有dp[i]种方法

2.递推公式：dp[i]=dp[i-1]+dp[i-2]

3.初始化：通过递推公式可知得到dp[i]需要前两项的dp,所以初始化dp[1]和dp[2].初始化dp[0]没有任何意义

4.遍历顺序：有递推公式可知从前往后遍历

5.验证dp

746. 使用最小花费爬楼梯

注意题目描述：每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯

思路

动规五部曲：

1.dp[i]及其下标的含义：dp[i]表示走到第i层台阶需要花费的最少金额

2.递推公式：dp[i]=min(dp[i-1],dp[i-2])+cost[i];

3.初始化：和上题一样是初始化dp[1],dp[2];

4.遍历顺序由递推公式从前向后遍历

5.打印dp

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size());
        dp[0] = cost[0];
        dp[1] = cost[1];
        for (int i = 2; i < cost.size(); i++) {
            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
        }
        // 注意最后一步可以理解为不用花费，所以取倒数第一步，第二步的最少值
        return min(dp[cost.size() - 1], dp[cost.size() - 2]);
    }
};

62.不同路径

思路：

动规五部曲：

1.dp[i][j]及其下标的含义：到横坐标为i纵坐标为j的地方有dp[i][j-1]种方法。

2.递推公式：dp[i][j]=dp[i-1][j]+dp[i][j-1];

3.初始化：由递推公式可知，我们必须初始化确定第0行和第0列的元素值，到达第0行和第0列只有一种方法

4.遍历顺序：从上到下，从左到右。

5.打印确定dp

63. 不同路径 II

思路：

关于遇到障碍，我们要考虑是哪里遇到了障碍，如果在第0行或者第0列遇到了障碍，那么遇到障碍前的地方初始化为1，遇到障碍后的地方初始化为0.当我们在遍历过程中遍历到障碍的时候，dp[i][j]赋值为0.其他地方与上题无异

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
	if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        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. 整数拆分

思路：

动规五部曲：

1.dp[i]及其下标的定义：dp[i]表示整数i拆分成的最大乘积。

2.递推公式：dp[i]=max(dp[i-j]*j,j*(i-j))

可想dp[i]最大乘积是怎么的到呢？

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

一个是j*(i-j)直接相乘。一个是j*dp[i-j]，相当于拆分(i-j),对这个拆分不理解的话，可以回想dp数组的定义。

那么有同学问了，j怎么不拆分？

j从1开始遍历，拆分j的情况，在遍历j的过程中已经计算过了，那么从1遍历j,比较（i-j)*j和dp[i-j]*j取最大的。递推公式：dp[i]=max(dp[i],max(i-j)*j,dp[i-j]*j));

也可以这么理解，j*(i-j)就是简单拆分成两个数相乘，但是j*dp[i-j]是拆分成3个以上的数相乘。

3.初始化:因为初始化dp[0]和dp[1]没有任何意义，所以我们初始化的最小值就是dp[2]=1

4.遍历顺序：由递推公式可知从前向后遍历

5.打印dp

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[2] = 1;
        for (int i = 3; i <= n ; i++) {
            for (int j = 1; j < i - 1; j++) {
                dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
            }
        }
        return dp[n];
    }
};

96.不同的二叉搜索树

思路：

首先写这道题就需要找规律，画出前几个二叉树，dp[1]=1,dp[2]=2,当搜索二叉树有两个节点时，以1为头结点，左子树为0，右子树为1，一共有一种形态。当以2位头结点的时候，左子树为1，右子树为0，有一种形态。当搜索二叉树有3个结点的时候，当以1为头结点时，左子树的形态和有两个结点时的形态相同，当以2为头结点时，左右子树的形态与只有一个结点的二叉搜索树相同，当以3为头结点时，右子树的形态与有两个结点的二叉搜索树相同。

动规五部曲：

1.dp[i]及其下标的含义： dp[i]代表有i个结点组成的二叉搜索树有dp[i]种形态

2.递推公式dp[i]+=dp[j-1]*dp[i-j];

3.初始化：遍历到叶子节点dp[0]=1.为什么让其等于1呢，因为为了计算如果将dp[0]赋值为0的话递推公式遍历到左右子树为0的情况将没有意义。

4.从前往后遍历。

5.打印dp

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;
        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];
    }
};