动态规划1

思考步骤

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

代码随想录动态规划理论基础

leetcode题目

62. 不同路径

利用排列组合

公式如下：

需要在计算分子的时候，不断除以分母，防止溢出
所以不用下面这个公式

这个题计算：

从左上角到右下角的过程中，我们需要移动 m+n−2 次，其中有 m−1 次向下移动，n−1 次向右移动。因此路径的总数，就等于从 m+n−2 次移动中选择 m−1 次向下移动的方案数

class Solution {
public:
    int uniquePaths(int m, int n) {
        long long ret = 1;
        for (int x = n, y = 1; y < m; ++x, ++y) {
            ret = ret * x / y;
        }
        return ret;
    }
};

动态规划

1. dp[i][j] ：表示从 (0 ,0) 出发，到 (i, j) 有 dp[i][j] 条不同的路径
2. dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
3. 初始化可以使用两种方式请看以下代码
4. 由递推公式得dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了

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

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

63. 不同路径 II

62中我们已经详细分析了没有障碍的情况，有障碍的话，其实就是标记对应的dp table（dp数组）保持初始值(0)就可以了。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        dp[1][0] = 1;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (obstacleGrid[i - 1][j - 1] == 1) {
                    dp[i][j] = 0;
                } else
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m][n];
    }
};

343. 整数拆分

1. dp[i]：拆分数字i，可以得到的最大乘积为dp[i]
2. 递推公式：dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});
3. 初始化dp[2] = 1
4. 从前向后遍历

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1, 0);
        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(dp[i], max(j * dp[i - j], j * (i - j)));
            }
        }
        return dp[n];
    }
};

96. 不同的二叉搜索树

1. dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。
2. 递推公式：dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量
3. 初始化dp[0] = 1
4. 遍历i里面每一个数作为头结点的状态，用j来遍历

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1, 0);
        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];
    }
};