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.

这题很有意思，是LeetCode上最有意思的题目之一。

我的解法时间复杂度是O(N)。我没想明白需要怎么描述我的解法，就不写了。

需要注意S="a",T="aa"的情况。

package leetcode;

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;

public class MinimumWindowSubstring {
	public static void main(String[] args) {
		System.out.println(new MinimumWindowSubstring().minWindow("ADOBECODEBANC", "ABC"));
	}
	
	public String minWindow(String S, String T) {
		if (T.length() > S.length()) {
			return "";
		}
		
		//各字符在T中出现的次数
        HashMap<Character, Integer> countMap = new HashMap<Character, Integer>();
        for (int i = 0; i < T.length(); i++) {
        	Integer count = countMap.get(T.charAt(i));
        	if (count == null) {
        		count = 0;
        	}
        	countMap.put(T.charAt(i), count+1);
        }
        
        //搜索S时，保存出现的字符和索引，KEY是字符，List保存字符在S中的索引，
        //因为T中可能出现重复字符的情况，如S="aa",T="aa"。同一字符可能需要多次匹配，故将其在S中出现的坐标需要保存在List中
        HashMap<Character, LinkedList<Integer>> map = new HashMap<Character, LinkedList<Integer>>();
        
        
        //引入indexMap和indexQueue，以方便查找minIndex
        boolean[] indexMap = new boolean[S.length()];//标记S中的字符是否出现当前待选匹配中
        Arrays.fill(indexMap, false);
        LinkedList<Integer> indexQueue = new LinkedList<Integer>();//保存S中出现的所有T中字符
        
        int index = 0;
        int minLen = Integer.MAX_VALUE;
        int minIndex = -1;
        int minStart = -1;
        int windowCount = 0;
        while (index < S.length()) {
        	char c = S.charAt(index);
        	Integer count = countMap.get(c);
        	if (count != null) {
        		LinkedList<Integer> indexList = map.get(c);
        		if (indexList == null) {
        			indexList = new LinkedList<Integer>();
        			map.put(c, indexList);
        		}
        		if (indexList.size() == count) {
        			indexList.add(index);
        			
        			Integer firstIndex = indexList.getFirst();
        			indexList.removeFirst();
        			
        			indexMap[firstIndex] = false;
        			indexMap[index] = true;
        			indexQueue.addLast(index);
        			
        			//update minIndex
        			if (firstIndex == minIndex) {
        				Integer inx = indexQueue.getFirst();
        				while (!indexMap[inx]) {
        					indexQueue.removeFirst();
        					inx = indexQueue.getFirst();
        				}
        				
        				minIndex = inx;
        			}
        		} else {
        			indexList.add(index);
        			if (minIndex == -1) {
        				minIndex = index;
        			}
        			windowCount++;
        			
        			indexMap[index] = true;
        			indexQueue.addLast(index);
        		}
        		
        		if (windowCount == T.length()) { //get an answer
            		int len = index - minIndex + 1;
            		if (len < minLen) {
            			minLen = len;
            			minStart = minIndex;
            		}
            	}
        	}
        	
        	index++;
        }
        if (minStart == -1) {
        	return "";
        }
        return S.substring(minStart, minStart + minLen);
    }
}