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.

public class Solution {
    public String minWindow(String S, String T) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(S == null || S.length() == 0 || T == null || T.length() == 0) return "";
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        int head = 0, tail = 0;
        int min = S.length() + 1;
        String result = "";
        int appeared = 0;
        HashMap<Integer, Integer> t = new HashMap<Integer, Integer>();
        for(int i = 0; i < T.length(); i ++){
            int c = (int)T.charAt(i);
            if(!t.containsKey(c)) t.put(c, 1);
            else t.put(c, t.get(c) + 1);
        }
        for(tail = 0; tail < S.length(); tail ++){
            int indexx = (int)S.charAt(tail);
            if(t.containsKey(indexx)){
                if(map.containsKey(indexx)){
                    map.put(indexx, map.get(indexx) + 1);
                    if(map.get(indexx) <= t.get(indexx)) appeared ++;
                }else{
                    appeared ++;
                    map.put(indexx, 1);
                }
                if(appeared == T.length()){
                    while(head <= tail){
                        int index = (int)S.charAt(head);
                        if(t.containsKey(index)){
                            if(map.get(index) == t.get(index)){
                                map.put(index, map.get(index) - 1);
                                appeared --;
                                int cur = tail - head;
                                if(min > cur){
                                    min = cur;
                                    result = S.substring(head, tail + 1);
                                }
                                head ++;
                                break;
                            }else if(map.get(index) > t.get(index)){
                                map.put(index, map.get(index) - 1);
                            }
                        }
                        head ++;
                    }
                }
            }
        }
        return result;
    }
}

 也可以在循环的时候只存左右两个index，而不存string， 以speed up。

public String minWindow(String S, String T) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(S==null || T==null) return "";
        Map<Character,Integer> total = new HashMap<Character,Integer>();
        for(int i=0;i<T.length();i++){
            char c = T.charAt(i);
            if(total.containsKey(c))
                total.put(c,total.get(c)+1);
            else
                total.put(c,1);
        } 
        
        Map<Character,Integer> covered = new HashMap<Character,Integer>();
        int start=0,
            end=-1,
            cur1=0,
            cur2=0,
            count=0;

        while(cur1<S.length() && cur2<S.length()){
            while(cur1<S.length() && !total.containsKey(S.charAt(cur1))) 
                cur1++;
                
            if(cur1<S.length()){
                if(cur2<cur1) cur2=cur1;
                
                if(count<T.length()){
                    while(cur2<S.length() && !total.containsKey(S.charAt(cur2))) 
                        cur2++;
                    if(cur2<S.length()){
                        char c = S.charAt(cur2);   
                        if(!covered.containsKey(c) ){
                            covered.put(c,1);
                            count++;
                        }else{                        
                            if(covered.get(c)<total.get(c)) 
                                count++;
                            covered.put(c,covered.get(c)+1);
                        } 
                        if(count<T.length()) cur2++;
                    }
                }else{
                    if(start>end || end-start>cur2-cur1){
                        end=cur2;
                        start=cur1;
                    }
                    char c = S.charAt(cur1);
                    covered.put(c,covered.get(c)-1);
                    cur1++;
                    if(covered.get(c)<total.get(c)){
                         count--;
                         cur2++;
                    }
                }
            }
        }
        return  S.substring(start,end+1);
    }

class Solution {
public:
    string minWindow(string S, string T) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int markT[300];
        int count[300];
        for (int i=0; i<300; i++)
            markT[i] = count[i] = 0;
        int totnum=0, curnum=0;
        for (int i=0; i<T.length(); i++){
            if ( markT[T[i]]==0 ) totnum++;            
            markT[T[i]]++;
        }
        string ret="";
        for (int i=0, j=0; j<S.length(); j++ ){
            if ( markT[S[j]] ){
                count[S[j]]++;
                if ( count[S[j]]==markT[S[j]] ) curnum++;
            }
            while ( i<=j && curnum==totnum ){
                if ( ret=="" || j-i+1<ret.length() )
                    ret = S.substr( i, j-i+1 );
                if ( markT[S[i]] ){
                    if ( count[S[i]]==markT[S[i]] ) curnum--;
                    count[S[i]]--;
                }
                i++;
            }
        }
        return ret;
    }
};