2024.06.18 刷题日记

最新推荐文章于 2024-06-21 23:09:58 发布

瑜陀

最新推荐文章于 2024-06-21 23:09:58 发布

阅读量403

点赞数 5

分类专栏： LeetCode 文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/m0_73651896/article/details/139779578

版权

LeetCode 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

76. 最小覆盖子串

这道题目的思路是利用哈希表来存储字符串的字符出现的频率，然后利用滑动窗口来确定是否包含目标串，如果没有包含，就继续滑动右指针。当子串已经包含的时候，就收缩窗口，更新答案，以及右移 left。

class Solution {
public:
    string minWindow(string s, string t) {
        // 滑动窗口
        int left = 0, right = 0;
        unordered_map<char, int> s_map, t_map;
        char temp, c;
        for (int ch : t) {
            t_map[ch]++;
        }
        int reque = t_map.size();
        int formed = 0;

        vector<int> ans = {0, 0, -1}; // left,right,len

        while (right < s.size()) {
            temp = s[right];
            s_map[temp]++;
            // 拓展右指针
            if (t_map.find(temp) != t_map.end() && s_map[temp] == t_map[temp]) {
                formed++;
            }
            // 左指针收缩
            while (left <= right && formed == reque) {
                c = s[left];
                // 更新答案
                if (ans[2] == -1 || ans[2] > right - left + 1) {
                    ans[0] = left;
                    ans[1] = right;
                    ans[2] = right - left + 1;
                }
                // 缩小
                s_map[c]--;
                if (t_map.find(c) != t_map.end() && s_map[c] < t_map[c]) {
                    formed--;
                }
                left++;
            }
            right++;
        }
        return ans[2] == -1 ? "" : s.substr(ans[0], ans[2]);
    }
};

53. 最大子数组和

动态规划，确定状态：current_sum 为当前 num[i] 为结尾最大和子串；状态转移方程：current_sum = max(nums[i], current_sum + nums[i])，因此代码不难写出：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int current_sum = nums[0]; // 初始化为第一个元素
        int max_sum = nums[0];     // 初始化为第一个元素

        for (int i = 1; i < nums.size(); i++) {
            current_sum = max(nums[i], current_sum + nums[i]);
            max_sum = max(max_sum, current_sum);
        }

        return max_sum;
    }
};

56. 合并区间

思路是首先排序，然后进行合并。合并时满足：merged.back()[1] >= interval[0]；否则，直接存储：

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.empty())
            return {};

        // 对区间进行排序，根据每个区间的起始位置
        sort(intervals.begin(), intervals.end(),
             [](const vector<int>& a, const vector<int>& b) {
                 return a[0] < b[0];
             });

        vector<vector<int>> merged;
        for (auto& interval : intervals) {
            // 如果merged为空或者当前区间不与merged中的最后一个区间重叠
            if (merged.empty() || merged.back()[1] < interval[0]) {
                merged.push_back(interval);
            } else {
                // 否则，有重叠，进行合并
                merged.back()[1] = max(merged.back()[1], interval[1]);
            }
        }
        return merged;
    }
};

189. 轮转数组

三次翻转就可以：

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        k = k % n; // 处理 k 大于数组长度的情况
        reverse(nums.begin(), nums.end()); // 反转整个数组
        reverse(nums.begin(), nums.begin() + k); // 反转前 k 个元素
        reverse(nums.begin() + k, nums.end()); // 反转剩下的元素
    }
};

238. 除自身以外数组的乘积

这里使用到了前缀积，然后前缀积乘以后缀积，就得到了当前下标的解：

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, 1);
        // 前缀积
        int preMul = 1;
        for (int i = 0; i < n; i++) {
            ans[i] = preMul;
            preMul *= nums[i];
        }

        // 后缀积
        int postMul = 1;
        for (int i = n - 1; i >= 0; i--) {
            ans[i] *= postMul;
            postMul *= nums[i];
        }

        return ans;
    }
};