Leetcode hot100
动态规划
1.最大子数组和
最大子数组和
动态规划：
按照四个步骤求解：
1）确定状态 ：以n代表第n个元素为末尾的最大子序列和
最后一步：加不加nums[n]子问题：pre(n-1)+nums[n] 与 nums[n] 的最大值，也就是说，已经求出前n项的最大子序列值A了，此时A>0则相加，若A<0则不相加；
2）转移方程：
//pre是全局变量，这是最关键的部分，有点类似于最大前缀和，如果说加了当前 nums[i]
//还小于不加，那么就把之前的前缀都扔掉，从当前的数重新累加
pre(n) = max(pre(n-1)+nums[n] , nums[n]);
ans = max(ans, pre);3）初始和边界条件 ：pre(0)=nums[0]；
4）计算顺序：pre(0)、pre(1)...
cpp
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int pre = 0, maxAns = nums[0];
for (auto x: nums) {
pre = max(pre + x, x);
maxAns = max(maxAns, pre);
}
return maxAns;
}
};2.不同路径
1）确定状态：dp[i][j]代表走到[i][j]网格的路径数目；
2）转移方程：d[i][j]=d[i-1][j]+d[i][j-1]；
3）边界条件：最左一列和最上一行只能为1，因为只能一步步往下或者一步步往右；
4）计算顺序：先一行，再列。
cpp
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];
}
};3.最小路径和
1）确定状态：dp[i][j]代表走到[i][j]网格的最小和；
2）转移方程：dp[i][j] = nums[i][j] + min(d[i-1][j],d[i][j-1])；
3）边界条件：dp[0][0] = grid[i][j] 、最左一列，dp[i][0]=dp[i-1][0]+grid[i][0]、最右一列，dp[0][j]=dp[0]d[j-1]+grid[0][j] 、正常列，dp[i][j]=dp[i-1][j]+grid[i][j-1]；最主要的就是考虑到最左只能往下走，最上一行只能往右走；
4）计算顺序：先一行，再列。
cpp
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
int n = grid.size(), m = grid[0].size();
vector<vector<int>> minAns(n, vector<int>(m, 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) minAns[i][j] = grid[0][0];
else if(i == 0 && j != 0) minAns[i][j] = minAns[i][j-1] + grid[i][j];
else if(j == 0 && i != 0) minAns[i][j] = minAns[i-1][j] + grid[i][j];
else minAns[i][j] = grid[i][j] + min(minAns[i - 1][j], minAns[i][j - 1]);
}
}
return minAns[n - 1][m - 1];
}
};4. 爬楼梯
1）确定状态：dp[i] 为爬到第 i 个台阶可以有多少种方法；
2）转移方程：dp[i] = dp[i - 1] + dp[i - 2]；
3）边界条件：dp[1] = 1, dp[2] = 2；
4）计算顺序：dp[1], dp[2]...
cpp
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (i == 1) dp[1] = 1;
else if (i == 2) dp[2] = 2;
else dp[i] = dp[i -1] + dp[i -2];
}
return dp[n];
}
};5. 杨辉三角
1）确定状态：dp[i][j] 为[i][j] 位置上的数字和；
2）转移方程：dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]；
3）边界条件：dp[0][0] = 1; 并且每一行的第一个和最后一个元素都为1，dp[i][0] = 1, dp[i][row] = 1
4）计算顺序：先行后列
注意：如果dp已经在初始化确定大小，那么可以利用dp[i][j]直接赋值，否则，只能push_back
resize用法：C++ std::vector::resize() 方法解析
cpp
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>> dp(numRows);
for (int i = 0; i < numRows; i++) {
dp[i].resize(i + 1);
for (int j = 0; j <= i; j++) {
if (j == 0) dp[i][j] = 1;
else if (j == i) dp[i][j] = 1;
else dp[i][j] = dp[i -1][j - 1] + dp[i - 1][j];
}
}
return dp;
}
};6.打家劫舍
1）确定状态：dp[i] 为 i 位置上能抢到的最大钱数；
2）转移方程：dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
3）边界条件：dp[0] = nums[0], dp[1] = max(nums[0], nums[1])
4）计算顺序：dp[0], dp[1]...
刚开始完全理解错误，以为必须是隔一个偷，这样只需计算dp[0]和dp[1]，输出max
cpp
class Solution {
public:
int rob(vector<int>& nums) {
if (nums.size() == 1) return nums[0];
if (nums.size() == 2) return nums[0] > nums[1] ? nums[0] : nums[1];
long ans1 = 0, ans2 = 0;
for (int i = 0; i < nums.size(); i = i+2) {
ans1 += nums[i];
}
for (int i = 1; i < nums.size(); i = i+2) {
ans2 += nums[i];
}
return max(ans1, ans2);
}
};发现这个测试用例失败：
2,1,1,2
输出
3
预期结果
4
cpp
class Solution {
public:
int rob(vector<int>& nums) {
if (nums.size() == 1) return nums[0];
if (nums.size() == 2) return nums[0] > nums[1] ? nums[0] : nums[1];
vector<int> dp(nums.size() + 1);
dp[0] = nums[0];
for (int i = 1; i < nums.size(); i++) {
if (i == 1) dp[i] = max(nums[0], nums[1]);
else dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[nums.size() - 1];
}
};