76. 最小覆盖子串 - 力扣（LeetCode）

---

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量
• 如果 s 中存在这样的子串，我们保证它是唯一的答案

---

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'

示例 2：

输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串

滑动窗口知识（这些文字来自 笨猪爆破组，详细文章链接在下文）

（1）窗口的扩张

• 扩张窗口是为了纳入目标字符，右指针右移，先找到可行解——纳入了所有目标字符。
• 在还没找齐目标字符之前，左指针不动。因为如果此时它右移，可能丢失现有的目标字符。
• 什么时候停止扩张窗口？——当前窗口包含了所有目标字符。
• 此时再纳入字符，条件依然满足，但徒增子串长度。此时应该优化可行解：收窄窗口，左指针右移。

（2）窗口的收缩

• 保持条件满足的情况下，收缩窗口是优化可行解。当窗口不再包含所有目标字符，即有目标字符丢失，就不再收缩。
• 此时应该扩张窗口，补充目标字符。
• 可见，为了找到最优解，一直做两种操作之一，直到窗口的右端到达边界。

（3）滑动窗口的套路

• 先找到一个可行解，再优化这个可行解。
• 优化到不能优化，产生出一个可能的最优解。
• 继续找新的可行解，再优化这个可行解。 ……
• 在所有可能的最优解中，比较出最优解

作者：笨猪爆破组
链接：https://leetcode.cn/problems/minimum-window-substring/solutions/2500882/leetcode-76-zui-xiao-fu-gai-zi-chuan-hua-ul9n/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 

从左->到下->到右->到下看以下图 

 

（1）思路1：用一个哈希map

class Solution {
public:
    bool check(unordered_map<char,int> mp) {
        for(auto it:mp){
            if(it.second > 0) return false;
	    }
        return true;
    }
    string minWindow(string s, string t) {
        unordered_map<char,int> need;
        int strStart=0,windowLen=INT_MAX;
        int left=0,right=0;
        for(char c:t) {
            need[c]+=1;
        }
        while(right < s.size()) {
            char curChar = s[right];
            if(need.find(curChar)!=need.end()) need[curChar]--;
            while(check(need)) {
                // 更新窗口的长度和起始位置
                int curWindowLen = right-left+1;
                if(curWindowLen < windowLen) {
                    windowLen = curWindowLen;//更新窗口的长度
                    strStart=left;//更新窗口的起始位置
                }
                //继续缩小窗口
                char leftChar = s[left];
                if(need.find(leftChar)!=need.end()) need[leftChar]++;
                left++;
            }
            right++;
        }
        if(windowLen != INT_MAX) return s.substr(strStart,windowLen);
        return "";
    }
};

（2）思路2：实际上还可以把哈希map换成数组，原理其实都是一样的，来看下代码

class Solution {
public:
    string minWindow(string s, string t) {
        vector<int>need(128);
        for(char c:t) {
            need[c]+=1;
        }
        int charCount = t.size();
        int left=0,right=0;
        int strStart=0,windowLen=INT_MAX;
        while(right < s.size()) {
            char curChar = s[right];
            if(need[curChar] > 0) {
                need[curChar]--;
                charCount--;
            }else need[curChar]--;
            while(charCount==0) {
                // 更新窗口的长度和起始位置
                int curWindowLen = right-left+1;
                if(curWindowLen < windowLen) {
                    windowLen = curWindowLen;//更新窗口的长度
                    strStart=left;//更新窗口的起始位置
                }
                //继续缩小窗口
                char leftChar = s[left];
                if(need[leftChar] == 0) {
                    need[leftChar]++;
                    charCount++;
                }else need[leftChar]++;
                left++;
            }
            right++;
        }
        if(windowLen != INT_MAX) return s.substr(strStart,windowLen);
        return "";
    }
};

 我们可以简化一下代码：

if(need[curChar] > 0) {
    need[curChar]--;
    charCount--;
}else need[curChar]--;

可以写成
if(need[curChar]-- > 0) {
    charCount--;
}

if(need[leftChar] == 0) {
    need[leftChar]++;
    charCount++;
}else need[leftChar]++;

可以写成
if(need[leftChar]++ == 0) charCount++;

（2.1）于是，就有如下代码：

class Solution {
public:
    string minWindow(string s, string t) {
        vector<int>need(128);
        for(char c:t) {
            need[c]+=1;
        }
        int charCount = t.size();
        int left=0,right=0;
        int strStart=0,windowLen=INT_MAX;
        while(right < s.size()) {
            char curChar = s[right];
            if(need[curChar]-- > 0) {
                charCount--;
            }
            while(charCount==0) {
                // 更新窗口的长度和起始位置
                int curWindowLen = right-left+1;
                if(curWindowLen < windowLen) {
                    windowLen = curWindowLen;//更新窗口的长度
                    strStart=left;//更新窗口的起始位置
                }
                //继续缩小窗口
                char leftChar = s[left];
                if(need[leftChar]++ == 0) charCount++;
                left++;
            }
            right++;
        }
        if(windowLen != INT_MAX) return s.substr(strStart,windowLen);
        return "";
    }
};

很多题解会写成这样，好处是减少一步加一操作。但是看的时候可能会有点懵

① 思路1的改进：

while(right < s.size()) {
    char curChar = s[right];
    if(need.find(curChar)!=need.end()) need[curChar]--;
    while(check(need)) {
        // 更新窗口的长度和起始位置
        int curWindowLen = right-left+1;
        if(curWindowLen < windowLen) {
            windowLen = curWindowLen;//更新窗口的长度
            strStart=left;//更新窗口的起始位置
        }
        //继续缩小窗口
        ...
        ...
        ...
    }
    right++;
}

========================================================

while(right < s.size()) {
    char curChar = s[right];
    if(need.find(curChar)!=need.end()) need[curChar]--;
    right++;
    while(check(need)) {
        // 更新窗口的长度和起始位置
        if(right-left< windowLen) {
            windowLen = right-left;//更新窗口的长度
            strStart=left;//更新窗口的起始位置
        }
        //继续缩小窗口
        ...
        ...
        ...
    }
}

 ② 思路2的改进

while(right < s.size()) {
    char curChar = s[right];
    if(need[curChar]-- > 0) {
        charCount--;
    }
    while(charCount==0) {
        // 更新窗口的长度和起始位置
        int curWindowLen = right-left+1;
        if(curWindowLen < windowLen) {
            windowLen = curWindowLen;//更新窗口的长度
            strStart=left;//更新窗口的起始位置
        }
        //继续缩小窗口
        ...
        ...
        ...
    }
    right++;
}

========================================================

while(right < s.size()) {
    if(need[s[right++]]-- > 0) {
        charCount--;
    }
    while(charCount==0) {
        // 更新窗口的长度和起始位置
        if(right-left< windowLen) {
            windowLen = right-left;//更新窗口的长度
            strStart=left;//更新窗口的起始位置
        }
        //继续缩小窗口
        ...
        ...
        ...
    }
}

（3） 用两个哈希map

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char,int> need;
        unordered_map<char,int> window;
        for(auto c:t) {
            need[c]+=1;
        }
        int right=0,left=0;
        int valid=0;
        int start=0,minLen=INT_MAX;
        while(right < s.size()) {
            char cur = s[right];
            // 进行窗口数据一系列更新
            if(need.find(cur)!=need.end()) {
                window[cur]++;
                if(window[cur] == need[cur]) valid++;
            }
            while(need.size() == valid) {
                if(right - left + 1 < minLen) {
                    start = left;
                    minLen = right - left + 1;
                }
                // d 是将移除窗口的字符串
                char deleteChar = s[left];
                // 进行窗口内数据当一系列更新
                if(window.find(deleteChar)!=window.end()) {
                    if(window[deleteChar] == need[deleteChar]) valid--;
                    window[deleteChar]--;
                }
                // 左边移动窗口
                left++;
            }
            right++;
        }
        return minLen == INT_MAX ? "" : s.substr(start,minLen);
    }
};

推荐和参考文章：76. 最小覆盖子串 - 力扣（LeetCode）https://leetcode.cn/problems/minimum-window-substring/solutions/736507/shu-ju-jie-gou-he-suan-fa-hua-dong-chuan-p6ip/

76. 最小覆盖子串 - 力扣（LeetCode）https://leetcode.cn/problems/minimum-window-substring/solutions/257928/yi-bu-bu-xing-cheng-hua-dong-chuang-kou-si-lu-shen/ 此题的另一种思路，参考笨猪爆破组写的C++版本，感兴趣的友友可以移步看一下喔！

leetCode 76. 最小覆盖子串 + 滑动窗口 + 哈希Hash-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/134088989?spm=1001.2014.3001.5501