LeetCode---76.最小覆盖子串

思路：map映射＋滑动窗口（自己思路+gpt代码调试）

分别定义两个map。第一个map记为tCount，用于保存子串t的映射；第二个map记为windowCount用于保存当前窗口内的字符映射。初始化双指针l，r分别为0，用于记录当前窗口边界。

第一步：先更新windowCount，直至其包含t中的所有字符

第二步：开始不断尝试收缩左边界，看是否影响windowCount包含整个子串，如果不影响则继续收缩，影响就先停止收缩。然后通过左移r，来使windowCount重新包含整个子串，重复该过程，直至完全收缩。在每次重新包含整个子串时都要对最小长度进行更新，并且记录该子串的起始位置。

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <limits>
using namespace std;

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> tCount;
        for (char c : t) {
            tCount[c]++;
        }
        // map.size返回的是map中的映射对数，所以才能比较
        int required = tCount.size();
        int l = 0, r = 0;
        int formed = 0;
        unordered_map<char, int> windowCount;
        int minLength = s.size()+10;
        int minLeft = 0;

        while (r < s.size()) {
            char c = s[r];
            windowCount[c]++;
            
            if (tCount.count(c) && windowCount[c] == tCount[c]) {
                formed++;
            }
            // 当前窗口已经拥有所有字串
            while (l <= r && formed == required) {
                c = s[l];

                // Update the minimum window
                if (r - l + 1 < minLength) {
                    minLength = r - l + 1;
                    minLeft = l;
                }

                windowCount[c]--;
                if (tCount.count(c) && windowCount[c] < tCount[c]) {
                    formed--;
                }
                l++;
            }
            r++;
        }

        return minLength == s.size()+10 ? "" : s.substr(minLeft, minLength);
    }
};

时间复杂度：O(n),即遍历整个s字符串

空间复杂度; O(m)，保存子串t的哈希映射