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.

难度：90    String问题里面有很多不好做的，动不动就DP什么的，参考了一些资料http://blog.csdn.net/fightforyourdream/article/details/17373203

For example,
S = “ADOBECODEBANC”
T = “ABC”
Minimum window is “BANC”.

Thoughts:
The idea is from here. I try to rephrase it a little bit here. The general idea is that we find a window first, not necessarily the minimum, but it’s the first one we could find, traveling from the beginning of S. We could easily do this by keeping a count of the target characters we have found. After finding an candidate solution, we try to optimize it. We do this by going forward in S and trying to see if we could replace the first character of our candidate. If we find one, we then find a new candidate and we update our knowledge about the minimum. We keep doing this until we reach the end of S. For the giving example:

1. We start with our very first window: “ADOBEC”, windowSize = 6. We now have “A”:1, “B”:1, “C”:1 （保存在needToFind数组里）
2. We skip the following character “ODE” since none of them is in our target T. We then see another “B” so we update “B”:2. Our candidate solution starts with an “A” so getting another “B” cannot make us a “trade”. （体现在代码就是只有满足hasFound[S.charAt(start)] > needToFind[S.charAt(start)]) 才能移动左指针start）
3. We then see another “A” so we update “A”:2. Now we have two “A”s and we know we only need 1. If we keep the new position of this “A” and disregard the old one, we could move forward of our starting position of window. We move from A->D->O->B. Can we keep moving? Yes, since we know we have 2 “B”s so we can also disregard this one. So keep moving until we hit “C”: we only have 1 “C” so we have to stop. Therefore, we have a new candidate solution, “CODEBA”. Our new map is updated to “A”:1, “B”:1, “C”:1.
4. We skip the next “N” （这里忽略所有不在T的字符：用needToFind[S.charAt(start)] == 0来判断） and we arrive at “C”. Now we have two “C”s so we can move forward the starting position of last candidate: we move along this path C->O->D->E until we hit “B”. We only have one “B” so we have to stop. We have yet another new candidate, “BANC”.
5. We have hit the end of S so we just output our best candidate, which is “BANC”.

底下这个做法看似简单，其实里面各种精巧的设计啊：先找到满足条件的一个window(不一定是最优)，每次移动右窗口，吸纳一个新元素进去，如果不是目标元素就跳过continue，如果是的话，hasFound数组对应位置值+1，然后看能不能优化窗口大小 by 看能不能移动左窗口，移动条件就是：始终保证窗口里面含有一个T的所有必要元素（个数要保证），直到移不动为止（再移就无法保证一个完整T的各元素个数了），这时就找到一个新的window，看是否最优。

public class Solution {
    public String minWindow(String S, String T) {
        int[] hasFound = new int[256];
        int[] needtoFind = new int[256];
        for (int i=0; i<T.length(); i++) {
            needtoFind[(int)(T.charAt(i)-'')]++;
        }
        int count = 0;
        int start = 0;
        int end = 0;
        String minWindow = "";
        int minWinSize = Integer.MAX_VALUE;
        for (; end<S.length(); end++) {
            if (needtoFind[(int)(S.charAt(end)-'')] == 0) continue;
            char c = S.charAt(end);
            hasFound[(int)(c-'')]++;
            if (hasFound[(int)(c-'')] <= needtoFind[(int)(c-'')]) {
                count++;
            }
            if (count == T.length()) { //the current window contains at least T, optimize the window now
                while (needtoFind[S.charAt(start)]==0 || hasFound[S.charAt(start)]>needtoFind[S.charAt(start)]) {
                    if (hasFound[S.charAt(start)] > needtoFind[S.charAt(start)]) {
                        hasFound[S.charAt(start)]--;
                    }
                    start++;
                }
                if (end-start+1 < minWinSize) {
                    minWinSize = end - start + 1;
                    minWindow = S.substring(start, end+1);
                }
            }
        }
        return minWindow;
    }
}

在处理字符串时候用数组比Hashtable要来的方便, 当然这道题也可用HashMap来做:

class Solution {
    public String minWindow(String s, String t) {
        if (s == null || s.length() == 0 || t == null || t.length() == 0 ) return "";
        HashMap<Character, Integer> target = new HashMap<>();
        for (int i = 0; i < t.length(); i ++) {
            target.put(t.charAt(i), target.getOrDefault(t.charAt(i), 0) + 1);
        }
        
        int l = 0, r = 0, minLen = Integer.MAX_VALUE;
        String res = "";
        HashMap<Character, Integer> actual = new HashMap<>();
        
        int count = 0;
        
        for (; r < s.length(); r ++) {
            char cur = s.charAt(r);
            actual.put(cur, actual.getOrDefault(cur, 0) + 1);
            if (actual.get(cur) <= target.getOrDefault(cur, 0)) count ++;
            
            if (count < t.length()) continue;
            
            //shrink left edge
            while (l <= r && actual.get(s.charAt(l)) > target.getOrDefault(s.charAt(l), 0)) {
                actual.put(s.charAt(l), actual.get(s.charAt(l)) - 1);
                l ++;
            }
            
            if (minLen > r - l + 1) {
                minLen = r - l + 1;
                res = s.substring(l, r + 1);
            }
        }
        
        return res;
    }
}

Here's a Window solving template. 

for (; r < s.length(); r ++) {
            char cur = s.charAt(r);
            //add to some collection
            
            //shrink left edge
            while (l <= r && r - l > someCondition)) {
                l ++;
            }
            // [l, r] is currently a valid window 
            if (minLen > r - l + 1) {
                minLen = r - l + 1;
                res = s.substring(l, r + 1);
            }
        }