1月做题记录
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int target) {
// 怎么把米需要的转化为你需要的呢？
int sum = 0；
// 先把数组总和求出来
for(int i = 0 ;i < nums.size(); i++) sum += nums[i];
if(abs(target) > sum) return 0; //此时没有方案
int bagsize = (target + sum) / 2;
vector<int> dp(bagsize + 1, 0);
// 默认初始值设置为1
dp[0] = 1;
for(int i = 0; i < nums.size() ; i++){
for(int j = bagsize; j >= nums[i]; j--){
dp[j] += dp[j - nums[i]];
}
}
return dp[bagsize];
}
};
打家劫舍
思路分析：
step 1：
先对异常情况进行 初始化 比如说没有值的情况 就直接返回0
有值但是只有一个值的话 直接返回nums[0]
step 2:
对dp数组进行初始化 dp(num.size())
然后进行第一个设值 dp[0] = nums[0]
dp[1] = 前两个值中最小的
step 3：
对背包进行遍历 从 int i = 2 开始 到num.size() 结束
这个确认的事
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
step 4：
最后 return dp[num.size() - 1];
class Solution {
public:
int rob(vector<int>& nums) {
// 对两个异常情况进行设置
if(nums.size() == 0) return 0;
if(nums.size() == 1) return nums[0];
// 第一步 对dp的大小进行初始化 然后对于dp的初值进行设置
vector<int> dp(nums.size());
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
// 确定遍历顺序 dp[i] 是根据dp [i - 2] dp[i - 1]推导和遍历出来的
for(int i = 2; i < nums.size(); i++){
// 先确定背包大小
dp[i] = max(dp[i - 2] + nums[i] , dp[i - 1]);
}
return dp[nums.size() - 1];
}
};
打家劫舍2
思路 不包含右节点 不包含左节点 做两次 比较最大值
打家劫舍3
树的后序遍历
思路：
如果是 根上没有节点的 直接返回0
根上有节点的 返回根上的节点值
如果umap有记录 直接返回记录的值
判断 偷父节点的 就不偷子节点 直接跨过
判断 不偷父节点 那么就要偷子节点
最后标记值得出一个两者中的最大值 返回一个最大值
class Solution {
public:
unordered_map<TreeNode*, int> umap;
// 使用这个可以记录计算过的结果
int rob(TreeNode* root) {
// 根上没有节点的 直接返回值0
if(root == NULL) return 0;
// 根上有节点的 返回根上的节点值
if(root -> left == NULL && root -> right == NULL) return root -> val;
// 如果umap[root]有记录 则直接返回
if(umap[root]) return umap[root];
// 第一个值偷父节点
int val1 = root -> val;
if(root -> left) val1 += rob(root -> left -> left) + rob(root -> left -> right);
if(root -> right) val1 += rob(root -> right -> left) + rob(root -> right -> right);
// 第二个值 不偷父节点
int val2 = rob(root -> left) + rob(root -> right);
umap[root] = max(val1, val2);
return max(val1, val2);
}
};
动态规划之 LeetCode：121.买卖股票的最佳时机1
思路
动规思路
step1
dp[i][0]持有这只股票 dp[i][1]不持有这只股票的状态
持有这只股票的最大收益 max(dp[i - 1][0], -prices[i])
不持有这只股票的最大收益 max(dp[i - 1][1], +prices[i])
step2
初始化dp[1][0] = -prices[0]
dp[1][1] = 0;
step3
for(int i = 1 ; i< prices.size(); i++){
求出收益最大值
}
step4
返回收益
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
if(len == 0) return 0;
vector<vector<int>> dp(len, vector<int>(2));
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < len; i++){
dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
II、买卖股票
这一题和上面一提的思路不一样的位置就是 买股票的价格不是初始值0 了
因为上一题是只卖一次股票 现在这一题不一样了 要买卖多次所以 除了之前持有 还是之前不持有 - 这一系持有（也就是这一次买这只股票）
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
vector<vector<int>> dp(len, vector<int>(2, 0));
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < len; i++){
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
III、买卖股票
思路： 买卖至多两次 那么这个问题分成了五种情况
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size() == 0) return 0;
vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
dp[0][1] = -prices[0];
dp[0][3] = -prices[0];
for(int i = 1; i < prices.size(); i++){
dp[i][0] = dp[i - 1][0];
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
}
return dp[prices.size() - 1][4];
}
};
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size() == 0) return 0;
vector<int> dp(5, 0);
dp[1] = -prices[0];
dp[3] = -prices[0];
for(int i = 1; i < prices.size(); i++){
dp[1] = max(dp[1],dp[0] - prices[i]);
dp[2] = max(dp[2],dp[1] + prices[i]);
dp[3] = max(dp[3],dp[2] - prices[i]);
dp[4] = max(dp[4],dp[3] + prices[i]);
}
return dp[4];
}
};
IV买卖股票
至多可以买卖k次 那么j可以用循环表示
最长递增子序列
思路
异常值处理 0,1 啥的
step 1：
遍历i的循环在外层，遍历j在内层
for(int i = 1; i < num.size();i++){
for(int j = 0; j < i; j++){
if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
}
if(dp[i] > result) result = dp[i];
}
step 2:
默认dp数组只为1
step 3：
result作为记录标志 只要比它大 就有值
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size() <= 1) return nums.size();
vector<int> dp(nums.size(), 1);
int result = 0;
for(int i = 1; i < nums.size(); i++){
for(int j = 0 ;j < i; j++){
if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
}
if(dp[i] > result) result = dp[i]; //取最长的子序列
}
return result;
}
};
最长递增子序列
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if (nums.size() == 0) return 0;
int result = 1;
vector<int> dp(nums.size() ,1);
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) { // 连续记录
dp[i] = dp[i - 1] + 1;
}
if (dp[i] > result) result = dp[i];
}
return result;
}
};
718. 最长重复子数组
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
int result = 0;
for(int i = 1; i <= nums1.size(); i++){
for(int j = 1; j <= nums2.size(); j++){
if(nums1[i - 1] == nums2[j - 1]){
dp[i][j] = dp[i - 1][j - 1] + 1;
}
if(dp[i][j] > result) result = dp[i][j];
}
}
return result;
}
};
1143.最长公共子序列 不想交的线
思路：
step 1：
先初始化默认的数组大小 dp【0】【0】 第0 行 第0列 全部设置为0
step2：
设置双层for循环 遍历dp【i】【j】数组
step3
判定 如果是text[i - 1] == text2[j - 1] 那么+1 斜上角
反之 dp[i][j] = 左边和上边的最大值
step4
返回dp的终值
53.最大子序和
class Solution {
public:
int maxSubArray(vector<int>& nums) {
// 如果nums.size() == 0; 那么返回0
if(nums.size() == 0) return 0;
// 初始化 dp数组
vector<int> dp(nums.size());
// 默认dp[0] == nums[0]
dp[0] = nums[0];
// result = dp[0]
int result = dp[0];
fpr(int i = 1; i < nums.size(); i++){
dp[i] = max(dp[i - 1] + nums[i], nums[i]);
// 这个是标志 如果保存dp[i]的最大值
if(dp[i] > result) result = dp[i];
}
return result;
}
};
115 不同的子序列
class Solution {
public:
int numDistinct(string s, string t) {
vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
for (int i = 0; i < s.size(); i++) dp[i][0] = 1;
for (int j = 1; j < t.size(); j++) dp[0][j] = 0;
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[s.size()][t.size()];
}
};
739 每日温度
思路：
先初始化一个单调递增栈
初始化result一个数组
判断单调栈的栈顶以及遍历当前的数值
stack<int> st;
vector<int> result(T.size(), 0);
st.push(0);
for(int i = 1; i < T.size(); i++){
if(T[i] <= T[st.top()]){
st.push();
}else{
while(!st.empty() && T[i] < T[st.top()]){
result[st.top()] = i - st.top();
st.pop();
}
st.push(i);
}
}
return result;
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& temperatures) {
stack<int> st;
vector<int> result(temperatures.size(), 0);
st.push(0);
for(int i = 1; i < temperatures.size(); i++){
if(temperatures[i] <= temperatures[st.top()]){
st.push(i);
}else{
while(!st.empty() && temperatures[i] > temperatures[st.top()]){
result[st.top()] = i - st.top();
st.pop();
}
st.push(i);
}
}
return result;
}
};
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
