LeetCode（76）： 最小覆蓋子串

Hard！

題目描述：

給定一個字符串 S 和一個字符串 T，請在 S 中找出包含 T 所有字母的最小子串。

示例：

輸入: S = "ADOBECODEBANC", T = "ABC"
輸出: "BANC"

說明：

• 如果 S 中不存這樣的子串，則返回空字符串 ""。
• 如果 S 中存在這樣的子串，我們保證它是唯一的答案。

解題思路：

這道題的要求是要在O(n)的時間度里實現找到這個最小窗口字串，那么暴力搜索Brute Force肯定是不能用的，我們可以考慮哈希表，其中key是T中的字符，value是該字符出現的次數。

- 我們最開始先掃描一遍T，把對應的字符及其出現的次數存到哈希表中。

- 然后開始遍歷S，遇到T中的字符，就把對應的哈希表中的value減一，直到包含了T中的所有的字符，紀錄一個字串並更新最小字串值。

- 將子窗口的左邊界向右移，略掉不在T中的字符，如果某個在T中的字符出現的次數大於哈希表中的value，則也可以跳過該字符。

C++解法一：

class Solution {
public:
    string minWindow(string S, string T) {
        if (T.size() > S.size()) return "";
        string res = "";
        int left = 0, count = 0, minLen = S.size() + 1;
        unordered_map<char, int> m;
        for (int i = 0; i < T.size(); ++i) {
            if (m.find(T[i]) != m.end()) ++m[T[i]];
            else m[T[i]] = 1;
        }
        for (int right = 0; right < S.size(); ++right) {
            if (m.find(S[right]) != m.end()) {
                --m[S[right]];
                if (m[S[right]] >= 0) ++count;
                while (count == T.size()) {
                    if (right - left + 1 < minLen) {
                        minLen = right - left + 1;
                        res = S.substr(left, minLen);
                    }
                    if (m.find(S[left]) != m.end()) {
                        ++m[S[left]];
                        if (m[S[left]] > 0) --count;
                    }
                    ++left;
                }
            }
        }
        return res;
    }
};

這道題也可以不用哈希表，直接用個int的數組來代替，因為ASCII只有256個字符，所以用兩個大小為256的int數組即可代替哈希表，其余部分的思路完全相同。

C++解法二：

class Solution {
public:
    string minWindow(string S, string T) {
        if (T.size() > S.size()) return "";
        string res = "";
        int left = 0, count = 0, minLen = S.size() + 1;
        int tm[256] = {0}, sm[256] = {0};
        for (int i = 0; i < T.size(); ++i) ++tm[T[i]];
        for (int right = 0; right < S.size(); ++right) {
            if (tm[S[right]] != 0) {
                ++sm[S[right]];
                if (sm[S[right]] <= tm[S[right]]) ++count;
                while (count == T.size()) {
                    if (right - left + 1 < minLen) {
                        minLen = right - left + 1;
                        res = S.substr(left, minLen);
                    }
                    if (tm[S[left]] != 0) {
                        --sm[S[left]];
                        if (sm[S[left]] < tm[S[left]]) --count;
                    }
                    ++left;
                }
            }
        }
        return res;
    }
};