leetcode题：76. 最小覆盖子串（困难）

一、题目描述：76. 最小覆盖子串（困难）

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。

示例：

输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
说明：

如果 S 中不存这样的子串，则返回空字符串 ""。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-window-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

滑动窗口算法的思路：

1、我们在字符串 S 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引闭区间 [left, right] 称为一个「窗口」。

2、我们先不断地增加 right 指针扩大窗口 [left, right]，直到窗口中的字符串符合要求（包含了 T 中的所有字符）。

3、此时，我们停止增加 right，转而不断增加 left 指针缩小窗口 [left, right]，直到窗口中的字符串不再符合要求（不包含 T 中的所有字符了）。同时，每次增加 left，我们都要更新一轮结果。

4、重复第 2 和第 3 步，直到 right 到达字符串 S 的尽头。

这个思路其实也不难，第 2 步相当于在寻找一个「可行解」，然后第 3 步在优化这个「可行解」，最终找到最优解。左右指针轮流前进，窗口大小增增减减，窗口不断向右滑动。

三、代码

class Solution {
public:
    string minWindow(string s, string t) {
        map<char,int> dp;
        map<char,int> sset;
        for(int i =0 ;i < t.size();i++)
        {
            sset[t[i]] = 0;
            dp[t[i]] = 0;
        }
        for(int i =0 ;i < t.size();i++)
        {
            //sset.insert(t[i]);
            dp[t[i]] += 1;
        }
        int left = 0;
        int right = 0;
        while(left<s.size() && dp.count(s[left]) == 0)
        {
            left++;
            
        }
        //cout<<"left="<<left<<endl;
        if(left==s.size())
            return "";
        right = left+1;
        sset[s[left]] += 1;
        int left_min = 0;
        int right_min = s.size()+2;
            //cout<<"left_ori="<<left<<endl;
            //cout<<"right_ori="<<right<<endl;
        if(check(dp,sset))
        {
                if(right_min - left_min > right - left)
                {
                    right_min  = right;
                    left_min = left;
                }
        }
        while(right<s.size())
        {
            while(right < s.size() && !check(dp,sset))
            {
                if(dp.count(s[right]) > 0)
                   {
                   sset[s[right]]+=1;
                   }
                 right ++;
            }
           // print(dp);
           // cout<<"print_set"<<endl;
           // print(sset);
            if(check(dp,sset))
            {
                if(right_min - left_min > right - left)
                {
                    right_min  = right;
                    left_min = left;
                }
            }
           // cout<<"left="<<left<<endl;
           // cout<<"right="<<right<<endl;
            if(right >= s.size() && !check(dp,sset))
                   break;
           // cout<<"left="<<left<<endl;
           // cout<<"right="<<right<<endl;
            
            while(left < right )
                   {
                    //if(dp.size() != sset.size())
                    //    break;
                char & c = s[left];
                if(dp.count(c) == 0)
                {
                    left++;
                    continue;
                }
                //cout<<"check="<<c<<endl;
            if(dp[c] == sset[s[left]])
            {
               
                sset[s[left]]--;
                 left++;
                break;
            }
            if(dp[c] < sset[s[left]])
            {
                
                sset[s[left]]--;
                left++;
            }
                   }
            //print(sset);
            //cout<<"left_l"<<left<<endl;
            //cout<<"right_r"<<right<<endl;
                   if(right_min - left_min > right - left)
                   {
                       right_min = right;
                       left_min = left-1;
                   }
                
        }
           // cout<<"left="<<left<<endl;
           // cout<<"right="<<right<<endl;
        if(right_min == s.size()+2)
        return "";
        if(left_min == 0)
            return s.substr(left_min,right_min - left_min);
        else
            return s.substr(left_min,right_min - left_min);
    }
    bool check_low(map<char,int> & dp,map<char,int> & sset,char &c)
    {
        if(dp.size() != sset.size())
            return false;
        if(dp.count(c) == 0)
            return true;
        if(dp[c] <= sset[c])
            return true;
        return false;
    }
    bool check(map<char,int> & dp,map<char,int> & sset)
    {
        if(dp.size() != sset.size())
            return false;
        for(auto it = dp.begin();it!= dp.end();it++)
        {
            if(it->second > sset[it->first])
                return false;
        }
        return true;
    }
    void print(map<char,int> & dp)
    {
        for(auto it = dp.begin();it!= dp.end();it++)
        {
            cout<<"char="<<it->first<<",count="<<it->second;
        }
        cout<<endl;
    }
};

代码二（别人优秀的代码）

在判断是子串是否包含字符串t的所有字母上使用一个map数组就解决了

class Solution {
public:
	string minWindow(string s, string t) {
        int count[256] = { 0 };
        for (auto c : t) ++count[c];
        int len = 0, minLength = s.length();
        string res;
        for (int l = 0, r = 0; r < s.length(); ++r) {
            if (--count[s[r]] >= 0) ++len;
            while (len == t.length()) {
                if (r - l + 1 <= minLength) {
                    minLength = r - l + 1;
                    res = s.substr(l, r - l + 1);
                }
                if (++count[s[l++]] > 0) --len;
            }
        }
        return res;
    }
};