[LeetCode]Substring with concatenation of all words

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

Analysis

同样可以采用滑动窗口法解决。在移动的过程中维护一个HashMap的字典，保存查找的字符串状况。

step 1.构建一个HashMap dict的字典，key-value对应words中的word和出现的次数。注意给定的words中可能多次出现同一个word。

step 2.设word的length为wLen（每个word的长度都相同），第一层循环wLen次，每次循环整个字符串。

step 3.第二层循环每次循环前进wLen位，遍历整个字符串，单次循环内次数为s.length()/wLen。这样两层循环就可以覆盖所有可能的字符串。用startIndex记录匹配字符串的开始位置，count记录匹配的字典字符串的个数。用另一个HashMap curMap维护当前匹配字符串中字典字符串的状况。通过比较dict和curMap的key-value来更新count和startIndex。注意：当前匹配的字典字符串在整个匹配字符串中出现的次数超出即curMap.get(sub) > dict.get(sub)，那么startIndex应直接移动到该匹配的字典字符串后一次出现位置之后，count同样减小。

packagecom.samxcode.leetcode;
 
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
 
/**
 * You are given a string, s, and a list of words, words, that are all of the same length. Find all
 * starting indices of substring(s) in s that is a concatenation of each word in words exactly once
 * and without any intervening characters.
 *
 * @author Sam
 *
 */
publicclassFindSubstring {
     
    publicstaticvoidmain(String[] args) {
        String[] words = {"a","b","a"};
        System.out.println(findSubstring("abababab", words));
    }
 
    publicstaticList<Integer> findSubstring(String s, String[] words) {
        List<Integer> res =newArrayList<Integer>();
        if(words.length ==0|| s.length() ==0) {
            returnres;
        }
        intwLen = words[0].length();
        // the count of special words displayed each loop
        intcount;
        // the start index each matching process
        intstartIndex;
        // put the given dictionary into hash map with each word's count
        HashMap<String, Integer> dict =newHashMap<String, Integer>();
        // dictionary in current matching process
        HashMap<String, Integer> curMap =newHashMap<String, Integer>();
        for(String word : words) {
            if(dict.containsKey(word))
                dict.put(word, dict.get(word) +1);
            else
                dict.put(word,1);
        }
        for(inti =0; i < wLen; i++) {
            count =0;
            startIndex = i;
            curMap.clear();
            for(intj = i; j <= s.length() - wLen; j += wLen) {
                // current word
                String sub = s.substring(j, j + wLen);
                if(dict.containsKey(sub)) {
                    // update current dictionary
                    if(curMap.containsKey(sub))
                        curMap.put(sub, curMap.get(sub) +1);
                    else
                        curMap.put(sub,1);
                    count++;
                    // check if count for current found word exceed given word count
                    if(curMap.get(sub) > dict.get(sub)) {
                        // shift the start index to the found word's next word and update the count
                        while(curMap.get(sub) > dict.get(sub)) {
                            String temp = s.substring(startIndex, startIndex + wLen);
                            curMap.put(temp, curMap.get(temp) -1);
                            startIndex += wLen;
                            count--;
                        }
                    }
                    // put the start index into result, shift index to next word, and update current
                    // dictionary and count
                    if(count == words.length) {
                        res.add(startIndex);
                        String temp = s.substring(startIndex, startIndex + wLen);
                        curMap.put(temp, curMap.get(temp) -1);
                        startIndex += wLen;
                        count--;
                    }
                }else{
                    curMap.clear();
                    startIndex = j + wLen;
                    count =0;
                }
 
            }
        }
        returnres;
    }
}

Complexity

第一层循环wLen次，第二层循环n/wLen次，所以时间复杂度O(n)，空间复杂度O(d*l)，s 字典大小，l 字典字符串长度