Leetcode hot100
动态规划
1.最大子数组和
最大子数组和
动态规划：
按照四个步骤求解：
1）确定状态 ：以n代表第n个元素为末尾的最大子序列和
最后一步：加不加numsn子问题：pre(n-1)+numsn 与 numsn 的最大值，也就是说，已经求出前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)=nums0；
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）确定状态：dpij代表走到ij网格的路径数目；
2）转移方程：dij=di-1j+dij-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）确定状态：dpij代表走到ij网格的最小和；
2）转移方程：dpij = numsij + min(di-1j,dij-1)；
3）边界条件：dp00 = gridij 、最左一列，dpi0=dpi-10+gridi0、最右一列，dp0j=dp0dj-1+grid0j 、正常列，dpij=dpi-1j+gridij-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）确定状态：dpi 为爬到第 i 个台阶可以有多少种方法；
2）转移方程：dpi = dpi - 1 + dpi - 2；
3）边界条件：dp1 = 1, dp2 = 2；
4）计算顺序：dp1, dp2...
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）确定状态：dpij 为ij 位置上的数字和；
2）转移方程：dpij = dpi - 1j - 1 + dpi - 1j；
3）边界条件：dp00 = 1; 并且每一行的第一个和最后一个元素都为1，dpi0 = 1, dpirow = 1
4）计算顺序：先行后列
注意：如果dp已经在初始化确定大小，那么可以利用dpij直接赋值，否则，只能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）确定状态：dpi 为 i 位置上能抢到的最大钱数；
2）转移方程：dpi = max(dpi - 2 + numsi, dpi - 1)
3）边界条件：dp0 = nums0, dp1 = max(nums0, nums1)
4）计算顺序：dp0, dp1...
刚开始完全理解错误，以为必须是隔一个偷，这样只需计算dp0和dp1，输出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];
}
};