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.

Have you been asked this question in an interview?

思路：
头尾两个指针，开始时都指向S的头，然后尾指针向后移动，知道头尾之间的窗口包含了所有T的字符；

然后收缩头指针，直到无法收缩（此时必然满足窗口中某字符个数等于T中该字符的个数，且头指针指向该字符）；

此时是个最小窗口的备选，记录下来；

然后头指针向后移一位，破坏平衡，尾指针向后扩展，又回到了第一步。

整个过程当尾指针到字符串尾部的时候终止。

由于每个字符被扫描两遍，时间复杂度为2n

string minWindow(string S, string T){
    int sa[128]={0};
    int ta[128]={0};
    int l,r;
    int len=0x0FFFFFFF;
    int count=0;
    int number=0;
    for(int i=0;i<T.length();i++)
        ta[T[i]]++;
    for(int i=0;i<128;i++){
        if(ta[i]>0)
            number++;
    }
    int m=-1;
    int n=-1;
    while(m<=n && n!=S.length()-1){
        for(int i=n+1;i<S.length();i++){
            if(ta[S[i]]>0){
                sa[S[i]]++;
                if(sa[S[i]]==ta[S[i]]){
                    count++;
                    if(count==number){
                        n=i;
                        break;
                    }
                }
            }
        }
        if(count<number)
            break;
        for(int i=m;i<=n;i++){
            if(ta[S[i]]>0){
                if(sa[S[i]]==ta[S[i]]){
                    m=i;
                    break;
                }
                else
                    sa[S[i]]--;

            }
        }
        if(n-m+1<len){
            len=n-m+1;
            l=m;
            r=n;
        }
        sa[S[m]]--;
        count--;
        m++;
    }
    if(len!=0x0FFFFFFF)
        return S.substr(l,len);
    else
        return "";
}

附上我自以为非常简洁的用贪心做的wrong answer，思想是头指针的进无可进的地方停下，尾指针从串尾扫起，在退无可退的地方停下。看似正确，但实际上却缩小了头指针的可能取值范围。

string minWindow(string S, string T){
    int sa[128]={0};
    int ta[128]={0};
    for(int i=0;i<T.length();i++)
        ta[T[i]]++;
    for(int i=0;i<S.length();i++){
        if(ta[S[i]]!=0)
            sa[S[i]]++;
    }
    for(int i=0;i<128;i++){
        if(sa[i]<ta[i])
            return "";
    }
    int m,n;
    for(m=0;m<S.length();m++){
        if(sa[S[m]]>0 && sa[S[m]]==ta[S[m]])
            break;
        else
            sa[S[m]]--;
    }
    for(n=S.length()-1;n>=m;n--){
        if(sa[S[n]]>0 && sa[S[n]]==ta[S[n]])
            break;
        else
            sa[S[n]]--;
    }
    return S.substr(m,n-m+1);
}