738.单调递增的数字

思路：在给的数字中找到第一个开始递减的两个数字 ； 将前一个数字减1 ； 后面的数字全部变为最大值9

 

 968.监控二叉树

思路：分三种状态：0无覆盖   1有监控   2有覆盖    分四种情况：1.两边都有覆盖，返回0  ；2.两边有一边无覆盖，返回1 ；3.两边有一边有监控，返回2 ；4.根节点无覆盖的情况

注意：要先考虑两边有一边无覆盖的情况，因为可能有 0  1 的情况，先考虑1的话导致一个节点没监控到 

63.不同路径||

思路：跟不同路径一样，多了一个障碍条件

1.初始化的时候，遇到1直接跳出

2.进行累加计算的时候，遇到障碍跳出当前循环（0种路径）

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int n=obstacleGrid.size(),m=obstacleGrid[0].size();
        //考虑障碍在起点、终点
        if(obstacleGrid[0][0]==1 || obstacleGrid[n-1][m-1]==1) return 0;
        vector<vector<int>>dp(n,vector<int>(m,0));//初始化为0
        for(int i=0;i<m;i++){//初始化
            if(obstacleGrid[0][i]==1) break;
            dp[0][i]=1;
        }
        for(int i=0;i<n;i++){
            if(obstacleGrid[i][0]==1) break;
            dp[i][0]=1;
        }
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                if(obstacleGrid[i][j]==1) continue;//遇到障碍
                else{
                    dp[i][j]+=dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        return dp[n-1][m-1];
    }
};

 

343.整数拆分（坐牢）

思路：

1.dp数组存储拆分i，得到的最大乘积

2.递推公式：从1开始遍历，然后有两种方式：j*(i-j)    j*dp[i-j] （并且0到i/2，因为后面的重复了）

3.初始化，只需要初始化dp[2]因为n>=2；并且0和1不需要拆分

4.遍历顺序：

class Solution {
public:
    int integerBreak(int n) {
        vector<int>dp(n+1);
        dp[2]=1;
        for(int i=3;i<=n;i++){
            //cout<<i<<endl;
            for(int j=1;j<=i/2;j++){//i/2后面的都重复了
                //cout<<"j*(i-j)："<<j*(i-j)<<" "<<"dp[i-j]*j："<<dp[i-j]*j<<endl;
                dp[i]=max(dp[i],max((i-j)*j,dp[i-j]*j));
            }
        }
        return dp[n];
    }
};

96.不同的二叉搜索树（坐牢）

思路：

1.dp存储的是i为节点的二叉搜索树的种数

2.递推公式：外层用 i 遍历1-n，内层用 j 遍历1-i，累加 dp[j-1] * dp[i-j]

3.初始化：dp[0]=1，因为0个节点就是二叉搜索树

4.遍历顺序：同2

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];
    }
};