代码随想录算法训练营第三十四天|不同路径、不同路径（有障碍）、整数拆分、不同的二叉搜索树

不同路径 leetcode 62

思路：走到[i,j]的位置一共有多少种走法，因为只能向右走或者向下走，那么到达[i,j]的上一步肯定是坐标从[i-1,j]向右走一步，或者从[i,j-1]向下走一步。

dp[i][j]的含义就是走到[i,j]坐标一共有多少条路径。根据思路递推公式就是dp[i][j]=dp[i-1][j]+dp[i][j-1]

dp数组初始化，因为每个坐标的路径都是由其上一格或者左面一格得来的，所以最上面一行以及最左面一行都要初始化，而且从start走到最上面一行任意位置以及最左面一行任意位置的路径只有一种，所以dp[i][0]=1，dp[0][j]=1。遍历顺序从前向后。

解法一：二维数组

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 i=0;i<n;i++) dp[0][i]=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];
    }
};

解法二：一维数组

dp[i]代表到达当前行第i列格子的路径数。递推公式为dp[i]=dp[i]+dp[i-1]，其中dp[i]表示当前格子的上一行同一列格子路径数，dp[i-1]表示左侧格子路径数。dp数组初始化，就是从当前行第一个格子出发到达当前行任意列格子的路径数都为1，所以dp[i]=1。

其实就是由外层for循环遍历每一行，先把到达每一行的路径数保存，最后层层覆盖，最后得到到达最后一行每一列的路径数。

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

解法三：数论

从start走到[m,n]不管怎么走肯定得向下走m-1步，向右走n-1步一共走m+n-2步，所以也就是说从n+m-2不同的数随便取其中的m-1个数一共多少种取法，C(m+n-2,m-1)。

class Solution {
public:
    int uniquePaths(int m, int n) {
        long long numerator = 1; // 分子
        int denominator = m - 1; // 分母
        int count = m - 1;
        int t = m + n - 2;
        while (count--) {
            numerator *= (t--);
            while (denominator != 0 && numerator % denominator == 0) {
                numerator /= denominator;
                denominator--;
            }
        }
        return numerator;
    }
};

不同路径Ⅱ leetcode 63

与上一题不同的是初始化，如果第一行和第一列有障碍物那么有障碍物之前的格子初始化为1，之后及障碍物格子初始化为0，还有一点不同就是for循环对dp[i]赋值时，如果遇到障碍物就跳过当前循环继续下一层循环。

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

总结

对于一个二维数组m，m.size()是数组的行数，m[0].size()是数组的列数。

整数拆分 leetcode 343

dp[i]表示将i拆成若干个数的乘积最大值。

对于每个拆分点j，一共三种情况，第一种将i拆为两部分也就是i*j，第二种就是将i拆为三个数及以上，也就是j*dp[i-j]，第三种情况dp[i]表示在固定i时各种拆分情况的值。所以递推公式为dp[i]=max(j*(i-j),j*dp[i-j],dp[i])。

初始化为dp[0]=0，dp[1]=0，dp[2]=1。

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

不同的二叉搜索树 leetcode 96

思路：若输入n，所有情况是分别以节点值为1到n做为根节点的所有二叉搜索树，其中每一种情况的数量是由其左子树种类×右子树种类，最后所有情况取和。

dp[i]表示由i个节点组成且节点值从1-i互不相同的二叉搜索树一共由dp[i]种。

递推公式，根据思路若以j为根节点则，dp[i]+=dp[j-1]*dp[i-j]。（for循环遍历j取和）。

初始化：dp[0]=1，dp[1]=1。

遍历顺序：从小到大。

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