代码随想录 第九章 动态规划part02 62.不同路径 63.不同路径 II 343.整数拆分 96.不同的二叉搜索树

62.不同路径

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

一个格子的路径可能性种类就是上侧与左侧格字路径可能性的和。

63.不同路径 II

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

这题的区别在于有障碍物，这就需要在求和的基础上增加对障碍物的处理，需要根据左侧与上侧是否有相邻障碍物判断如何计算。

343.整数拆分

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

这题的点在于理解max(result[i], max(j * (i - j), result[i - j] * j))，内侧的max包含的两个都是将数分为两部分求乘积，区别在于j * (i - j)只将数分为2部分，而result[i - j] * j实际上是将数分为至少3个部分因为result[i - j]是一个最大乘积，所以整个max(result[i], max(j * (i - j), result[i - j] * j))的意义就在于先找到不同不同拆分个数中的最大乘积，再看是否超过了之前的最大乘积。

96.不同的二叉搜索树

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

这题笔者觉得很妙，一个包含n个节点的二叉搜索树左侧与右侧子树各自的节点数都小于n，代表在动态规划的过程中这是已经求过的已知数，左侧与右侧节点数各自固定的情况下，由于搜索树的性质，根节点是唯一的，所以通过遍历所有两侧节点个数各自的搜索树可能性，相乘求和，就能得到答案。

代码随想录 第九章 动态规划part02