LeetCode —— Minimum Window Substring

最新推荐文章于 2021-02-25 13:50:42 发布

江枫abalone

最新推荐文章于 2021-02-25 13:50:42 发布

阅读量787

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 文章标签： leetcode HASH

本文链接：https://blog.youkuaiyun.com/niaokedaoren/article/details/8825989

LeetCode 专栏收录该内容

42 篇文章

订阅专栏

本文详细解析了LeetCode第76题“最小覆盖子串”的解决方案，介绍了使用滑动窗口与哈希表实现复杂度为O(n)的高效算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

链接：http://leetcode.com/onlinejudge#question_76

原题：

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"

Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the emtpy string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

思路：这题想了好长时间，STL的unordered_map也用的不熟，调试也很痛苦。

主要思想是用hash表存储T子串，用首尾索引来跟踪窗口。

第一步：找到一个包含T字符的窗口

第二步：把头部不必要的字符去掉，得到一个窗口长度值

第三步：继续把尾部索引向前走，如果出现和首部索引一样的字母，那么去掉头部的一些不必要字母，

形成新的窗口，比较长度值。

代码写丑了，写完后，查了一下，感觉自己的代码组织能力实在是太差了，这位大神给了个很漂亮的代码

http://blog.youkuaiyun.com/tingmei/article/details/8049577

class Solution {
public:
    string minWindow(string S, string T) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (S.size() < T.size() || T.size() == 0)
            return "";
        
        unordered_multiset<char> hashSet;
    	unordered_map<char, int> counter;
		unordered_map<char, int> benchmark;
		for (int i=0; i<T.size(); i++) {
			if (benchmark.find(T[i]) != benchmark.end())
				benchmark[T[i]] += 1;
			else
				benchmark[T[i]] = 1;
		}
        for (int i=0; i<T.size(); i++)
            hashSet.insert(T[i]);
        int start;
        int n = 0;
        vector<bool> flags(S.size(), false);
        for ( ; n < S.size(); n++) {
			unordered_multiset<char>::iterator itr = hashSet.find(S[n]);
            if (itr != hashSet.end()) {
                hashSet.erase(itr);
                start = n;
                flags[n] = true;
				counter[S[n]] = 1;
                break;
            }
        }
        if (hashSet.empty())
            return S.substr(start, 1);
        for (n++; n < S.size(); n++) {
            unordered_multiset<char>::iterator itr = hashSet.find(S[n]);
            if (itr != hashSet.end())
                hashSet.erase(itr);
			if (benchmark.count(S[n]) > 0) {
				flags[n] = true;
				if (counter.count(S[n]) > 0)
					counter[S[n]] += 1;
				else
					counter[S[n]] = 1;
			}
            
            if (hashSet.empty())
                break;
        }
        
        if (!hashSet.empty())
            return "";
        int pos = start;
		while (true) {
			if (flags[pos]) {
				if (benchmark[S[pos]] < counter[S[pos]])
					counter[S[pos]]--;
				else
					break;
			}
			pos++;
		}
		start = pos;
		int minLen = n - start + 1;
		
        for (n++; n < S.size(); n++) {
            if (counter.find(S[n]) != counter.end()) {
				counter[S[n]] += 1;
                flags[n] = true;
			}
            if (S[n] == S[start] ){
				while (true) {
					if (flags[start]) {
						if (benchmark[S[start]] < counter[S[start]])
							counter[S[start]]--;
						else
							break;
					}
					start++;
				}
                if (n - start + 1 < minLen) {
                    minLen = n - start + 1;
                    pos = start;
                }
            }
        }
        
        return S.substr(pos, minLen);
    }
};