算法训练1-day29-动态规划

1. 62. 不同路径

dp数组含义：到达(i,j)位置需要的步数

每一步只能向下或向左，也就意味着(i,j)只能来源于(i-1,j)或是(i,j-1)这两个位置，于是：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

AC代码：

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

// 空间压缩的版本
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<int> dp(n, 1);
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                dp[j] += dp[j - 1];
            }
        }
        return dp[n - 1];
    }
};

2. 63. 不同路径 II dp[i][j] ：表示从(0 ,0)出发，到(i, j) 有dp[i][j]条不同的路径。 AC代码：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int n = obstacleGrid.size();
        int 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));
        // i从0开始，处理[[0]]的情况
        for (int i = 0; i < n; ++i) {
            if (obstacleGrid[i][0] == 1) break;
            dp[i][0] = 1;
        }
        for (int j = 1; j < m; ++j) {
            if (obstacleGrid[0][j] == 1) break;
            dp[0][j] = 1;
        }
        for (int i = 1; i < n; ++i) {
            for (int j = 1; j < m; ++j) {
                if (obstacleGrid[i][j] != 1) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[n - 1][m - 1];
    }
};

3. 343. 整数拆分

分解步骤，固定一部分，变化另外一部分：比如我们看每一个i，都是j从1到i-1遍历，看按照j来分，能得到的乘积最大是多少，我们遍历所有可能，找出最大的那个

代码如下：

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

// 特殊的，我们尽可能的将n按照3来分，直到剩余的部分小于 等于4
class Solution {
public:
    int integerBreak(int n) {
        if (n == 2) return 1;
        if (n == 3) return 2;
        if (n == 4) return 4;
        int result = 1;
        while (n > 4) {
            result *= 3;
            n -= 3;
        }
        result *= n;
        return result;
    }
};

4. 96. 不同的二叉搜索树 dp数组的含义：节点个数为i的二叉搜索树的种类数 对于每一个i，我们可以依次取1-i作为根节点，

当取1作为根节点时，其左边没有节点，右边有i-1个节点，因此总共有dp[1-1]*dp[i-1]种； 当取2作为根节点，其左边有1个节点，右边有i-2个节点，因此总共有d[2-1]*dp[i-2]种； 后面以此类推

注意是左右子树的可能性相乘而非相加

class Solution {
public:
    int numTrees(int n) {
        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];
    }
};