代码随想录训练营Day30:动态规划2

1.62不同路径

1. dp[i][j]数组的定义：到达坐标（i，j）所需要的路径个数。
2. 递推公式：dp[i][j] = dp[i-1][j]+dp[i][j-1];//到达（i，j）的上一步只能是从上面到或者左边到
3. 初始化：对于到达（i,0）或者（0,j）只有一条路可以走。
4. 遍历顺序：因为dp[i][j]与上方和左方的数据有关，所以双重遍历按照从上到下，再从左到右。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,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];
    }
};

2.63不同路径二

1. dp[i][j]数组的定义：到达坐标（i，j）所需要的路径个数。
2. 递推公式：dp[i][j] = dp[i-1][j]+dp[i][j-1];//到达（i，j）的上一步只能是从上面到或者左边到，这里需要考虑的情况就是如果当前的位置是障碍的话，那么dp[i][j] = 0;因为怎样都无法走到这里
3. 初始化：对于第一行和第一列在未遇到障碍前设置为1，如果遇到了障碍，那么从这个开始全都是变为0.
4. 遍历顺序：因为dp[i][j]与上方和左方的数据有关，所以双重遍历按照从上到下，再从左到右。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));//到达(i,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){
                    dp[i][j] == 0;
                }else{
                    dp[i][j] = dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
};

3.343整数拆分

1.dp[i]:拆分成k>=2个之后的最大乘积

2.递推公式：dp[i] = max(max(dp[i],j*dp[i-j]),j*(i-j));//j*(i-j)代表的是拆分成两个，j*dp[i-j]代表的是拆分成k+1>2个的还有一个就是dp[i]代表的相当于前面的历史最大值。

为什么是这三个呢？因为dp[i-j]代表的拆分至少是2个再乘以j那么至少就是三个了，无法覆盖两个的情况，所以得把两个的单独提出来，dp[i]是因为我们要找到这一部分的最大值。

为什么只需要遍历一半呢？

因为根据数学知识，拆分成n个相近的值最大，而拆分的个数至少是2个，所以只需要遍历到i/2即可。

3.初始化：根据给定的定义初始化即可。

4.遍历顺序：我们可以看到递推公式可以知道我们需要从小到大遍历。

class Solution {
public:
    int integerBreak(int n) {
        //dp[i]:拆分成k个的最大的乘积
        vector<int> dp(n+1,1);//默认情况下dp[0]=1,dp[1] = 1,dp[2] =1;这个里面默认是有两个及以上的
        for(int i=3;i<=n;i++){
            for(int j =1;j<=i/2;j++){//只需要遍历一半就行
                dp[i] = max(max(dp[i],j*dp[i-j]),j*(i-j));
            }
        }
        return dp[n];
    }
};

4.96不同的搜索二叉树

1.dp[i]:节点个数为i的搜索二叉树的个数

2.递推公式：dp[i] += dp[j]*dp[i-j-1];我们将其分成三个部分：根节点（1）：左子树（j），右子树(i-j-1)，由于左右子树互不影响，要想求解此时对应节点分布情况下的搜索二叉树个数，所以需要用乘法来叠加。

3.初始化：默认情况下dp[0] = 1,dp[1] = 1;

4.遍历顺序：根据递推公式可以知道，其对应的和前面的值相关，所以遍历顺序应该是从小到大进行遍历。

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1,0);//dp数组代表的是i个节点的二叉搜索树的和
        dp[0] = 1; dp[1] = 1;
        //分为n种情况假设有i个节点，一个作为根节点，其中j个作为一个整体，i-j-1作为另外一个整体，那么这样的一共有多少种排序的方式
        //dp[j]*dp[i-j]
        //默认情况下dp[0] = 1,dp[1] = 1
        for(int i = 2;i<=n;i++){
            for(int j = 0;j<i;j++){
                dp[i] += dp[j]*dp[i-j-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];
    }
};