LeetCode Hot 100：子串-优快云博客

LeetCode Hot 100：子串

560. 和为 K 的子数组

思路 1：二重循环枚举（超时）

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        int count = 0;
        for (int start = 0; start < n; start++)
            for (int len = 1; len <= n - start; len++)
                if (accumulate(nums.begin() + start, nums.begin() + start + len,
                               0) == k)
                    count++;
        return count;
    }
};

思路 2：前缀和

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> preSum(n + 1, 0);
        for (int i = 1; i <= n; i++)
            preSum[i] = preSum[i - 1] + nums[i - 1];

        int count = 0;
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j <= n; j++)
                if (preSum[j] - preSum[i] == k)
                    count++;
        return count;
    }
};

哈希表优化：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> preSum(n + 1, 0);
        for (int i = 1; i <= n; i++)
            preSum[i] = preSum[i - 1] + nums[i - 1];

        int count = 0;
        unordered_map<int, int> hashMap; // <preSum, cnt>
        for (int i = 0; i <= n; i++) {
            if (hashMap.find(preSum[i] - k) != hashMap.end())
                count += hashMap[preSum[i] - k];
            hashMap[preSum[i]]++;
        }
        
        return count;
    }
};

239. 滑动窗口最大值

思路 1：暴力

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        for (int i = 0; i <= nums.size() - k; i++) {
            int max_num = INT_MIN;
            for (int j = i; j < i + k; j++)
                max_num = max(max_num, nums[j]);
            ans.push_back(max_num);
        }
        return ans;
    }
};

思路 2：优先队列

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
		if (k > n)
			return {};
			
        priority_queue<pair<int, int>> pq;
        for (int i = 0; i < k; i++)
            pq.push({nums[i], i});

        vector<int> ans;
        ans.push_back(pq.top().first);
        
        for (int i = k; i < n; i++) {
            pq.push({nums[i], i});
            while (!pq.empty() && pq.top().second <= i - k)
                pq.pop();
            ans.push_back(pq.top().first);
        }

        return ans;
    }
};

思路 3：双端队列

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> dq;
        vector<int> ans;
        for (int i = 0; i < nums.size(); i++) {
            if (!dq.empty() && dq.front() == i - k)
                dq.pop_front();
            while (!dq.empty() && nums[dq.back()] < nums[i])
                dq.pop_back();
            dq.push_back(i);
            if (i >= k - 1)
                ans.push_back(nums[dq.front()]);
        }
        return ans;
    }
};

76. 最小覆盖子串

思路 1：滑动窗口 + 哈希表

class Solution {
public:
    string minWindow(string s, string t) {
        int sLen = s.length(), tLen = t.length();
        if (sLen < tLen)
            return "";

        unordered_map<char, int> sCount, tCount;
        for (char& c : t)
            tCount[c]++;

        auto isCovered = [&]() -> bool {
            for (auto& [c, cnt] : tCount)
                if (sCount[c] < cnt)
                    return false;
            return true;
        };

        int start = -1, len = INT_MAX;
        for (int left = 0, right = 0; right < sLen; right++) {
            sCount[s[right]]++;
            while (isCovered()) {
                if (right - left + 1 < len) {
                    start = left;
                    len = right - left + 1;
                }
                sCount[s[left]]--;
                left++;
            }
        }

        return start == -1 ? "" : s.substr(start, len);
    }
};