1月做题记录+2月做题记录

于 2024-03-04 20:24:00 发布
阅读量347 收藏 10
点赞数 7
文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34626178/article/details/136461712
版权

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];

    
    }
};

打家劫舍

image-20240221112401171

思路分析：

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、买卖股票

image-20240223145607942

思路： 买卖至多两次 那么这个问题分成了五种情况

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可以用循环表示

最长递增子序列

image-20240226154050719

思路

异常值处理 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;

    }
};

最长递增子序列

image-20240226160526298

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. 最长重复子数组

image-20240226171544088

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.最长公共子序列 不想交的线

image-20240227165753141

思路：

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.最大子序和

image-20240227195819398

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 不同的子序列

image-20240228172055763

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 每日温度

image-20240301170449940

思路：
先初始化一个单调递增栈
初始化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;
    }
};
Aoife艺馨
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值