[LeetCode] Substring with Concatenation of All Words_you are given a string, s, and a list of words, l,

You are given a string, S, and a list of words, L, that are all of the same length. Find all starting indices of substring(s) in S that is a concatenation of each word in L exactly once and without any intervening characters.

For example, given:
S: "barfoothefoobarman"
L: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

public class Solution {
    public ArrayList<Integer> findSubstring(String S, String[] L) {
        // Start typing your Java solution below
        // DO NOT write main() function
        ArrayList<Integer> ret=new ArrayList<Integer>();
        if ( S==null || L==null || L.length==0 )
            return ret;
        HashMap<String,Integer> words=new HashMap<String,Integer>();
       // HashMap<String,Integer> need =new HashMap<String,Integer>();
        for(int i=0;i<L.length;i++){
        	if ( words.containsKey(L[i]) ){
        		int t = words.get(L[i]);
            	words.put(L[i], t+1);
            	//need.put(L[i], t+1);
        	}else{
        		words.put(L[i],1);
        	//	need.put(L[i],1);
        	}
        	
        }
        
        int wordLength=L[0].length();
        for(int i=0;i<wordLength;i++){
        	HashMap<String,Integer> need =new HashMap<String,Integer>(words);
            int start=i,end=i;
            int needCnt=L.length;
            if ( (S.length()-start)< (wordLength*needCnt))
                break;
                
            for(;end<S.length();end+=wordLength){
            	if ( S.length()-end < wordLength )
            		break;
                String tmp= S.substring(end,end+wordLength);
                if (words.containsKey(tmp)){
                	int t=need.get(tmp);
                    need.put(tmp,t-1);
                    if ( t>0)
                        needCnt--;
                }
                
                if ( needCnt==0 ){
                    while(true){
                        String toRemove=S.substring(start,start+wordLength);
                        if (words.containsKey(toRemove) ){
                        	int t =need.get(toRemove);
                            if ( t <0 ){
                            	need.put(toRemove,t+1);
                            }
                            else
                                break;
                        }
                        start+=wordLength;
                    }
                    if (end-start == wordLength*(L.length-1))
                        ret.add(start);
                }
            }
        }
        return ret;
    }
}