3. 无重复字符的最长子串 76. 最小覆盖子串(滑动窗口法)

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
  请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

解:此题可利用滑动窗口解法，利用一个set 找到重复的，就清楚之前重复值及之前的数，然后再次计算

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        set<char> set_char;
        //[i,j]  滑动窗口
        int i=0,j=0;
        int max_value=0;
        while(i<s.size()&&j<s.size())
        {
            //如果相同的字符未删掉，j是不会向前移动的
            if(set_char.find(s[j])==set_char.end())
            {
                max_value=max(max_value,j-i+1);
                set_char.insert(s[j++]);
            }
            else
            {
                set_char.erase(s[i++]);
            }
        }
        return max_value;
    }
};

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

示例：

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

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

解

class Solution {
public:
    string minWindow(string s, string t) {
        map<char,int> map_char;
        //目标字符串可能包含两个相同字符
        map<char,int> map_give_value;
        for(int pos=0;pos<t.size();pos++)
        {
            map_give_value[t[pos]]++;
        }

        int i=0,j=0,n=0,min_value=INT_MAX;
        int match=0;
        int start_pos=0;
        while(i<s.size()&&j<s.size())
        {
            if(map_give_value.count(s[j]))
            {
                map_char[s[j]]++;
                if(map_char[s[j]]==map_give_value[s[j]])
                {
                    match++;
                }
            }

            j++;
            while(match==map_give_value.size())
            {
                if(j-i<min_value)
                {
                    min_value=j-i;
                    start_pos=i;
                }

                if(map_char.count(s[i]))
                {
                    map_char[s[i]]--;
                    //防止同一个目标字符再S中出现多次
                    if(map_char[s[i]]<map_give_value[s[i]])
                    {
                        match--;
                    }
                }
                i++;

            }
        }
            return min_value == INT_MAX ?
                "" : s.substr(start_pos, min_value);
    }
};