LeetCode | Minimum Window Substring

题目：

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.

思路：

最基本的思路是设置一个首指针与一个尾指针，当未包含所有字符时，尾指针移动；当包含重复字符时，首指针移动。每次恰好包含所以字符时，记录是否为最小长度。这个方法的问题是尾指针经过的无效点，首指针可能会重复经过。如下例，首指针不动时，尾指针移动直到包含a...b，当尾指针移动到a...b...a时首指针开始移动，这时首指针需要重复移动尾指针经过的位置。
artwekbreqlawerla

优化的思路是针对每一个字符建立一个队列来记录字符出现的位置，当队列中的字符数大于T中需要的字符数时，队列中的首个字符便可以出列。
备注：ASCII码中有效的字符从'!'开始，共95个。

代码：

class Solution {
public:
    string minWindow(string S, string T) {
        
        int letters[95];
        int total = 0;
        for(int i=0;i<95;i++)
        {
            letters[i] = 0;
        }
        for(int i=0;i<T.size();i++)
        {
            total++;
            letters[char2Int(T[i])] += 1;
        }
        
        
        int hasLetter[95];
        for(int i=0;i<95;i++)
        {
            hasLetter[i]=0;
        }
        
        queue<int>* letterqueue = new queue<int>[95];
        int count=0;
        int min_s = 0;
        int min_e = S.size();
        for(int i=0;i<S.size();i++)
        {
            if(letters[char2Int(S[i])]>0)
            {
                if(hasLetter[char2Int(S[i])]<letters[char2Int(S[i])])
                {
                    count++;
                }
                else if(hasLetter[char2Int(S[i])]!=0)
                {
                    letterqueue[char2Int(S[i])].pop();
                    hasLetter[char2Int(S[i])]-=1;
                }
                hasLetter[char2Int(S[i])]+=1;
                letterqueue[char2Int(S[i])].push(i);
                if(count==total)
                {
                    int s=S.size();
                    int e = 0;
                    for(int j=0;j<95;j++)
                    {
                        if(letterqueue[j].size()>0)
                        {
                            if(s>letterqueue[j].front())
                            {
                                s=letterqueue[j].front();
                            }
                            if(e<letterqueue[j].back())
                            {
                                e=letterqueue[j].back();
                            }
                        }
                    }
                    if(e>=s&&min_e-min_s>e-s)
                    {
                        min_s = s;
                        min_e = e;
                    }
                }
            }
        }
        if(min_e!=S.size())
        {
            return S.substr(min_s,min_e-min_s+1);
        }
        else
        {
            return "";
        }
    }
    
    int char2Int(char c) 
    {
        return c-'!';
    }
};