62.不同路径
这一题由于题目一开始限定了每次我们只能向下走或者向右走，那么其实这道题的动规逻辑就相当清晰了。
- dp数组的含义：dpij代表走到第i行第j列的位置有多少种不同的方法
- 确定状态转移方程：由于第i行第j列只能从第i-1行第j列或者第i行第j-1列走到，所以这里的递推公式就是
dpij = dpi-1j + dpij-1
- 初始化：由于每个位置只能从左边或者上边拿到，所以最左边和最上边是一定需要初始化的。
那么该初始化为多少呢。显然每次只能向左或者向右走，那么最上边和最左边只能是1
所以dpi0 = 1,dp0j = 1
- 遍历顺序：由于每一个状态都是从左向右得到的，所以必须从左到右，从上到下遍历
- 打印dp数组
经过上述分析，可以写出如下代码：
sql
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 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 - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};时间复杂度: O(N)
空间复杂度: O(N²)
当然这题，由于后面状态始终依靠左边和上面得出，是可以优化为滚动数组版本的
sql
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];
}
};63. 不同路径 II
这道题是在上一题的基础上，加上了障碍物这个元素
那么显然，只需要在上述分析下修改一下即可
- dp数组的含义：dpij代表走到第i行第j列的位置有多少种不同的方法
- 确定状态转移方程：由于第i行第j列只能从第i-1行第j列或者第i行第j-1列走到，所以这里的递推公式就是
dpij = dpi-1j + dpij-1 (obstacleGridij == 0 没有障碍)
dpij = 0 (obstacleGridij == 1 有障碍)
- 初始化：由于每个位置只能从左边或者上边拿到，所以最左边和最上边是一定需要初始化的。
那么该初始化为多少呢。显然每次只能向左或者向右走，那么最上边和最左边只能是1
所以dpi0 = 1,dp0j = 1，但是如果遇到了障碍物的话，从障碍物开始之后所有的位置，全部需要写成0.
- 遍历顺序：由于每一个状态都是从左向右得到的，所以必须从左到右，从上到下遍历
- 打印dp数组
代码如下:
cpp
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) //如果在起点或终点出现了障碍，直接返回0
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 j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 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];
}
};当然这题同样也可以优化空间
代码如下：
cpp
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
if (obstacleGrid[0][0] == 1)
return 0;
vector<int> dp(obstacleGrid[0].size());
for (int j = 0; j < dp.size(); ++j)
if (obstacleGrid[0][j] == 1)
dp[j] = 0;
else if (j == 0)
dp[j] = 1;
else
dp[j] = dp[j-1];
for (int i = 1; i < obstacleGrid.size(); ++i)
for (int j = 0; j < dp.size(); ++j){
if (obstacleGrid[i][j] == 1)
dp[j] = 0;
else if (j != 0)
dp[j] = dp[j] + dp[j-1];
}
return dp.back();
}
};343. 整数拆分
这道题其实动规是相当难想到的，一起来分析一下吧！
对于一个数字n我们可以把他拆成2个数字的，也可以把他拆成多个数字
那现在如果我把dpi定义为i可以被拆分出的最大值的话，那么这个时候我们就需要将i拆分为j和i-j了显然这会有i组，而对于每组的i和i-j而言，我们可以只把他拆成i和i-j ，或者我们对i-j这个数字继续拆分成dpi-j（i-j拆分的最大值）。所以我们希望去这两个数里面大的那一个就有 在某一次拆分i和i-j时，dpi = max(ij,idpi-j)。
又因为i可以拆分为很多个这样的分组那么最终的状态转移方程为dpi = max(dpi, max(ij,idpi-j))。
代码如下:
cpp
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((i - j) * j, dp[i - j] * j));
}
}
return dp[n];
}
};96. .不同的二叉搜索树
这道题我们可以这样去思考，我们需要用n个节点，那么其中的一部分节点比如i个就会组成左子树，而另一部分j个就会组成右子树，那么n个节点的不同二叉搜索树的数量就是 左子树的数量 * 右子树的数量
假设，我们现在定义dpi为i个节点的不同二叉搜索树数量，那么dpn = dpi * dpn-i-1。
根据这样的分析乐意写出下述代码:
cpp
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[j - 1] * dp[i - j];
}
}
return dp[n];
}
};