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];
}
};
一个格子的路径可能性种类就是上侧与左侧格字路径可能性的和。
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];
}
};
这题的区别在于有障碍物,这就需要在求和的基础上增加对障碍物的处理,需要根据左侧与上侧是否有相邻障碍物判断如何计算。
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))的意义就在于先找到不同不同拆分个数中的最大乘积,再看是否超过了之前的最大乘积。
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,代表在动态规划的过程中这是已经求过的已知数,左侧与右侧节点数各自固定的情况下,由于搜索树的性质,根节点是唯一的,所以通过遍历所有两侧节点个数各自的搜索树可能性,相乘求和,就能得到答案。