给一个非常长的字符串str 另一个字符集比方{a,b,c} 找出str 里包括{a,b,c}的最短子串。要求O(n)

给一个非常长的字符串str 另一个字符集比方{a,b,c} 找出str 里包括{a,b,c}的最短子串。要求O(n).

比方，字符集是a,b,c，字符串是abdcaabcx，则最短子串为abc。

设置Front和Rear，使用对象记录字符集已有值的个数和位置，通过Front和Rear遍历字符串。

遍历过程为Rear在前，当遇到字符集中字符时，该字符个数加1，记录该字符位置。

出现字符集都出现时，计算字串长度；然后，front前移一位，假设此位在字符集中，清空对象记录字符集的状态。

最后获得字串的最小长度和字串位置。

import java.util.HashMap;
import java.util.Map;


public class TestMini {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TestMini min = new TestMini();
		min.init();
		System.out.println(min.run());
	}
	
	private String str = "abddddcasdfadfasdfsdfbcx";
	private Map<Character, Integer[]> map = new HashMap<Character, Integer[]>();
	
	public void init(){
		map.put('a', new Integer[]{0, 0});
		map.put('b', new Integer[]{0, 0});
		map.put('c', new Integer[]{0, 0});
	}

	public int run(){
		char[] chars = str.toCharArray();
		Object value = null;
		Integer[] il = null;
		int front = 0;
		int rear = 0;
		int minSum = chars.length;
		int count = 0;
		Object key = null;
		for(; rear < chars.length; rear++){
			key = chars[rear];
			value = map.get(key);
			if(value != null){
				il = (Integer[])value;
				il[1]++;
				il[0] = rear;
				if(isValid()){
					count = getCount();
					minSum = (minSum > count)? count : minSum;
					checkFront(front);
					front++;
				}
			}
		}
		return minSum+1;
	}
	
	private void checkFront(int front){
		Object value = map.get(str.charAt(front));
		if(value != null){
			Integer[] il = (Integer[])value;
			il[1]--;
			il[0] = 0;
		}
	}
	
	private boolean isValid(){
		for(Integer[] entry : map.values()){
			if(entry[1] <= 0){
				return false;
			}
		}
		return true;
	}
	
	private int getCount(){
		int min = str.length();
		int max = 0;
		for(Integer[] entry : map.values()){
			if(entry[0] < min){
				min = entry[0];
			}
			if(entry[0] > max){
				max = entry[0];
			}
		}
		return max - min;
	}
}