[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.

思路：双指针。前面的指针向前扩展到包含所有字符为止，这个时候有些字符可能有冗余，例如目标字符串"ab"，源字符串"aab"，当窗口包含所有字符时字符a存在冗余；又或者窗口末端存在无关字符，例如目标字符串"ab"，源字符串"cab"。无论哪种情况，在这个时候窗口都有可能被压缩，因此用后面的指针向前判断，直到压缩到不能再压缩为止。

        具体做法是，利用两个map，一个记录目标字符串每个字符的数量，另一个记录当前窗口中每个字符的数量，开始的时候两者是相等的。扩张的过程中，每当遇到目标字符串中的字符，则在当前窗口记录中将那个字符的数量减一。压缩的终止条件是，对于非相关字符，直接向前压缩，对于相关字符，判断剩余个数，如果小于0，说明有余量可以进行压缩，否则停止压缩，更新长度。

        其中的一个问题是，刚开始的时候，不可以进行压缩，需要先把所有字符都包括，然后再压缩。具体做法是，利用一个变量count记录目标字符串字符个数，在扩张的过程中，如果当前字符在目标字符串中，且当前窗口记录中该字符数量 ≥ 0，说明此次扩展囊括了一个有效字符，则count值减一；反例是目标字符串"ab"，源字符串"aab"，当扩张的第二个a时，a已经是-1了，说明第二个不是有效字符。当count为0时，即可以开始压缩。从这个时间节点往后，扩张和压缩即是动态进行，每扩张一个字符，进行一次压缩，同时更新窗口。

class Solution {
public:
    string minWindow(string S, string T) {
        int len = INT_MAX;
        string min_win = "";
        vector<int> src_record(256, 0);
        vector<int> cur_record(256, 0);
        for (int i = 0; i < T.size(); ++i) {
            src_record[T[i]]++;
            cur_record[T[i]]++;
        }
        int front = 0;
        int back = 0;
        int count = (int)T.size();
        for (; front < (int)S.size(); ++front) {
            if (src_record[S[front]] > 0) {   //the character is in T
                cur_record[S[front]]--;
                if (cur_record[S[front]] >= 0) {
                    count--;
                }
            }
            if (count == 0) {   //all characters in T are included
                // shrink the current window
                for (; back < front; ++back) {
                    if (src_record[S[back]] > 0) {
                        if (cur_record[S[back]] < 0) cur_record[S[back]]++;   //can shrink
                        else break;   //cannot shrink anymore
                    }
                }
                if (front - back + 1 < len) {   //update
                    len = front - back + 1;
                    min_win = S.substr(back, front - back + 1);
                }
            }
        }
        return min_win;
    }
};

总结：每个字符被两个指针访问一次，复杂度为O(n).