字符串窗口覆盖 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".

注意：题意中有一点没有说明确：如果T中有重复的字符（比如两个a），那么覆盖T的窗口字符串中也要有两个a。另外一点，输入字符串不只是含有大写字母。

思路：

一、如何找到一个窗口W能否覆盖T？

首先为T构建一个THash表，将T的所有字符都放入THash（允许重复元素放入）。再为窗口构建另一个WinHash表，遍历S的时候，如果是T中的字符串，则放入WinHash，并且在放入的过程中为其计数，当计数发现窗口足够覆盖T时，说明当前的窗口刚好覆盖T。

二、如果找到最小窗口。

第一点做完后就找到了第一个窗口。然后要做的是优化这个窗口。一方面，窗口的左侧在保证覆盖T的情况下试图收缩。另一方面，窗口的右侧试图继续向右扩展。这两方面并发交替的进行着，就能逐步向右移动窗口，并保证窗口尽量小。

这样一次遍历之后，就可以找到最优的窗口。

代码易错点：Hash表的构建、窗口内覆盖情况的计数

代码：

class Solution {
public:

    string minWindow(string S, string T) {
        size_t slen = S.size();
        size_t tlen = T.size();
        
        if(slen == 0)
            return string("");
        
        //为T创建静态的hash表
        int T_hash[256];
        memset(T_hash, 0, sizeof(T_hash));
        for(int i=0;i<tlen;i++)
            T_hash[T[i]]++;
        
        //为window构造动态的hash表：保存window中用于覆盖T的字符
        int window_hash[256];
        int window_hash_size = 0;
        memset(window_hash, 0, sizeof(window_hash));
        
        int left = 0, right = 0;
        for(;right<slen;right++)
        {
            if(window_hash_size < tlen) //相等时才能覆盖T
            {
                if(T_hash[S[right]] > 0)
                {
                    if(window_hash[S[right]] < T_hash[S[right]] )
                        window_hash_size++;
                    window_hash[S[right]]++;
                }
            }
            else
                break;
        }
        //left~right是最右边第一个window
        if(window_hash_size < tlen)
            return string("");
        
        string minwin = "";
        for(int i=left;i<right;i++)
            minwin += S[i];
        
        //不断调整窗口，向右扩展，向左缩小
        while(left<right)
        {   //左侧试图缩小
            if(T_hash[S[left]] == 0)
            {
                left++;
                continue;
            }
            if(window_hash[S[left]] > T_hash[S[left]])
            {
                window_hash[S[left]]--;
                left++;
                continue;
            }
            else
            {   //左侧无法缩小，记录当前最小，并准备向右扩展
                if(right - left < minwin.length())
                {
                    minwin = "";
                    for(int j=left;j<right;j++)
                        minwin += S[j];
                }
                
                if(right >= slen)
                    break;
                if(T_hash[S[right]] > 0)
                    window_hash[S[right]]++;
                right++;
            }
        }
        return minwin;
    }

};