3.1log | 62.不同路径,63. 不同路径 II，343. 整数拆分，96.不同的二叉搜索树

62.不同路径

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<n;i++) dp[0][i]=1;
        for(int i=0;i<m;i++) dp[i][0]=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
};

这道题和台阶题类似，到达下一个点是由上两个点决定的，即该点左侧的点和该点上面的点，到达该点的路径总和为dp[i][j]=dp[i-1][j]+dp[i][j-1],dp数组初始化为整个二维数组的上边界和左边界，因为是从左上角出发，行进方向只有向右和向下，所以遍历顺序为从左到右从上到下，用两层for从左到右一层一层遍历，注意末尾点是dp[m-1][n-1]，不是dp[m][n]

63. 不同路径 II

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));
        if(obstacleGrid[0][0]==1||obstacleGrid[m-1][n-1]==1) return 0;
        for(int i=0;i<m&&obstacleGrid[i][0]==0;i++) dp[i][0]=1;
        for(int i=0;i<n&&obstacleGrid[0][i]==0;i++) dp[0][i]=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(obstacleGrid[i][j]!=1)
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
                else dp[i][j]=0;
            }
        }
        return dp[m-1][n-1];
    }
};

这道题是上一题的升级版，但是需要注意几个前提条件，在初始化dp数组时，如果障碍物在最左和最上面边界中，则初始化终止，保持为0，当从左到右从上到下遍历dp数组时，遇到障碍物时，则dp[i][j]保持为0

343. 整数拆分

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/2;j++){
                dp[i]=max(dp[i],max(j*(i-j),j*dp[i-j]));
            }
        }
        return dp[n];
    }
};

这道题代码很简洁，但思维很麻烦，dp[i]的含义是整数i拆分后乘积的最大值，递推公式为dp[i]=max(dp[i]+max(j*(i-j),j*dp[i-j])),这个递推公式意思是，dp[i]不断更新其最大值，dp[i]的最大值由两方面决定，一是拆分为两个数，而是拆分为大于等于三个数以上的乘积，覆盖所以可能拆分的情况，最后取其最大值。vector数组未初始化，默认全为0

96.不同的二叉搜索树

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[i-j]*dp[j-1];
            }
        }
        return dp[n];
    }
};

dp数组的初始化只能初始化dp[0],其他dp数组值都是从零开始累加，如果有初值，就会增大，这道dp题利用了二叉搜索树的特性，顶点的左子树都是比它小的值，顶点的右子树都是比它大的值，所以就很好判断一个数，左右子树的个数，而个数的排列方式能进行状态转移，用于下一层递推，所以递推公式为dp[i]+=dp[i-j]*dp[j-1]