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

Analysis:

Use two map to store the expected char occured numbers(from T), realtime char occured numbers(From S)

Since we should implement this with O(n), we scan string S from the start to the end, use appeared varablile to recored how many chars have occued compared with T

If the (char is in T && its occued numbers < T), store it and its occued numbers in expectedMap, appeared++

If(appeared == T.lenth() )// substring could cover all chars in T

while(starting char is not in T || starting char numbers > expected number in T)

starting index++

if(win_len> current window length)

set new window

return ....

C++实现如下

string minWindow(string S, string T) {
        if(S.size() == 0) return "";
    if(T.size() > S.size()) return "";
    int appearCount[256];
    int expectCount[256];
    memset(appearCount,0,256*sizeof(appearCount[0]));
    memset(expectCount,0,256*sizeof(appearCount[0]));

    for(int i=0; i<T.size();i++){
        expectCount[T[i]]++;
    }
    int minV = INT_MAX, min_start=0;
    int wid_start =0;
    int appeared = 0;

    for(int wid_end = 0; wid_end<S.size(); wid_end++){
        if(expectCount[S[wid_end]] >0)
        {
            appearCount[S[wid_end]]++;
            if(appearCount[S[wid_end]] <= expectCount[S[wid_end]])
                appeared++;
        }
        if(appeared == T.size()){
            while((appearCount[S[wid_start]]>expectCount[S[wid_start]]) || expectCount[S[wid_start]]==0)
            {
                appearCount[S[wid_start]]--;
                wid_start++;
            }
            if(minV > (wid_end-wid_start+1))
            {
                minV = wid_end-wid_start+1;
                min_start = wid_start;
            }
        }
    }
    if(minV == INT_MAX) return"";
    return S.substr(min_start,minV);
    }

Java实现如下

public String minWindow(String S, String T) {
        int win_start = 0;
        int win_realS = 0;
        int win_len = Integer.MAX_VALUE;
        int appeared = 0;
        HashMap<Character, Integer> expected = new HashMap<Character, Integer>();
        HashMap<Character, Integer> realAppeared = new HashMap<Character, Integer>();
        for(int i=0;i<T.length();i++){//store T char into map
        	int val = 1;
        	if(expected.containsKey(T.charAt(i))){
        		val = expected.get(T.charAt(i));
        		val++;
        	}
        	expected.put(T.charAt(i), val);
        }
        for(int i=0;i<S.length();i++){
        	if(expected.containsKey(S.charAt(i))){
        		int val = 0;
        		if(realAppeared.containsKey(S.charAt(i))){
        			val = realAppeared.get(S.charAt(i));
        			val++;
        		}else{
        			val = 1;
        		}
        		realAppeared.put(S.charAt(i), val);
        		if(val<=expected.get(S.charAt(i)))
        			appeared++;
        	}
        	if(appeared == T.length()){//have all the chars
        		while(!expected.containsKey(S.charAt(win_start))
        				|| (expected.containsKey(S.charAt(win_start)) && realAppeared.get(S.charAt(win_start))>expected.get(S.charAt(win_start)))){
        			if(!expected.containsKey(S.charAt(win_start)))
        				win_start++;
        			else{
        			int val = realAppeared.get(S.charAt(win_start));
        			val--;
        			realAppeared.put(S.charAt(win_start), val);
        			win_start++;
        			}
        		}        		
        		if(win_len>i-win_start+1){
        			win_len = i-win_start+1;
        			win_realS = win_start;
        		}
        	}
        }
        return (win_len == Integer.MAX_VALUE) ? "" : S.substring(win_realS, win_realS+win_len);
    }