[leetcode-76]Minimum Window Substring(java)

问题描述：
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.

分析：首先，要求时间复杂度为O(n)，而比较的内容为两个字符串，很显然的，一定要利用到hash表，对于C++而言，可以利用字母的ASCII小于256这一特点做hash，对于java就无所谓了。
还有一点就是，T可能是重复的。我最开始的想法是，有一个T大小的数组，里面专门存满足条件的s的索引。同时，有个hashtable来存T的字符以及T的index的list。然后对于每个hash表里面的字母，移除到list中的第一个，然后获取索引然后更改索引数组的值，最后再插入到list的最后。
还有一个问题，就是怎么判断找全？我的想法是，再存个hash表，里面的value是对应char的次数，每来一个，减1，当为0时，移除。这样当hash表的为空时，就是找全了。这种方法见代码1，AC了，但是时间比较长。

这道题一般的想法是利用两个指针start,end;起初情况下，start = 0,end = 0;然后当end找全之后，start再向后移动到不能再移动，不能再移动的意思是要一直向右压缩，直到再压就会不满足条件时。
这种思路也是利用两个hash表，第一个hash表对T进行初始化，存每个字母出现的次数（needFound)。另外一个hash表存储从start到end出现的所有的满足条件的次数（hasFound)。
如何判断找全呢？利用一个计数器。当hasFound中插入的数小于needFound时，每添加一个，计数器+1.这样当计数器等于t.length()时便找全了所有的东西。此时start需要向右移动。移动的原则就是让hasFound找到对应的char，当它的计数==needFound需要的计数时便退出。如代码2所示。

这两种方法都是O(N)的时间复杂度。但是后者表达起来更优美一些。

代码1：932ms

public class Solution {
     public String minWindow(String s, String t) {
        HashMap<Character,Integer> needFound = new HashMap<>();
        HashMap<Character,Integer> hasFound = new HashMap<>();
        int min = Integer.MAX_VALUE;
        int minEnd=0,minStart=0;
        int end,start;

        char[] chars = t.toCharArray();
        //init hash table
        for(int i = 0;i<chars.length;i++){
            if(!needFound.containsKey(chars[i]))
                needFound.put(chars[i],0);
            int tmpVal = needFound.get(chars[i]);
            needFound.replace(chars[i],tmpVal+1);
        }

        chars = s.toCharArray();
        int count = 0;
        int tLength = t.length();

        start = 0;
        for(int i = 0;i<chars.length;i++){
            char val = chars[i];
            if(needFound.containsKey(val)){
                if(!hasFound.containsKey(val))
                    hasFound.put(val,0);
                int tmpVal = hasFound.get(val);
                hasFound.replace(val,++tmpVal);

                if(tmpVal<=needFound.get(val))
                    count++;
            }

            if(count==tLength){
                end = i;
                int tmpVal;
                //向右移动start
                while(start<end){
                    if(hasFound.containsKey(chars[start])){
                        if((tmpVal=hasFound.get(chars[start]))==needFound.get(chars[start]))
                            break;
                        hasFound.replace(chars[start],--tmpVal);
                    }
                    start++;
                }
                if((end-start+1)<min){
                    min = end-start+1;
                    minEnd = end+1;
                    minStart = start;
                }
                hasFound.replace(chars[start],hasFound.get(chars[start])-1);
                start++;
                count--;
            }
        }
        if(min==Integer.MAX_VALUE)
            return "";
        return s.substring(minStart,minEnd);
    }
}

代码2：516 ms

public class Solution {
     public String minWindow(String s, String t) {
        HashMap<Character,Integer> needFound = new HashMap<>();
        HashMap<Character,Integer> hasFound = new HashMap<>();
        int min = Integer.MAX_VALUE;
        int minEnd=0,minStart=0;
        int end,start;

        char[] chars = t.toCharArray();
        //init hash table
        for(int i = 0;i<chars.length;i++){
            if(!needFound.containsKey(chars[i]))
                needFound.put(chars[i],0);
            int tmpVal = needFound.get(chars[i]);
            needFound.replace(chars[i],tmpVal+1);
        }

        chars = s.toCharArray();
        int count = 0;
        int tLength = t.length();

        start = 0;
        for(int i = 0;i<chars.length;i++){
            char val = chars[i];
            if(needFound.containsKey(val)){
                if(!hasFound.containsKey(val))
                    hasFound.put(val,0);
                int tmpVal = hasFound.get(val);
                hasFound.replace(val,++tmpVal);

                if(tmpVal<=needFound.get(val))
                    count++;
            }

            if(count==tLength){
                end = i;
                int tmpVal;
                //向右移动start
                while(start<end){
                    if(hasFound.containsKey(chars[start])){
                        if((tmpVal=hasFound.get(chars[start]))==needFound.get(chars[start]))
                            break;
                        hasFound.replace(chars[start],--tmpVal);
                    }
                    start++;
                }
                if((end-start+1)<min){
                    min = end-start+1;
                    minEnd = end+1;
                    minStart = start;
                }
                hasFound.replace(chars[start],hasFound.get(chars[start])-1);
                start++;
                count--;
            }
        }
        if(min==Integer.MAX_VALUE)
            return "";
        return s.substring(minStart,minEnd);
    }
}