[leetcode]Substring with Concatenation of All Words

Substring with Concatenation of All Words

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

算法思路：

1. 遍历S，每遇到一个字符，就取出wordLength的长度，并验证是否在L中，如不在，i++，如在，进行loop迭代，直到找到一个concatenation （记录下来）或者失配。继续i++，时间复杂度最好为O(n)，最坏为O(n* num * wordLength)

public class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> findSubstring(String S, String[] L) {
        int num = L.length;
        int wordLength = L[0].length();
        if(S.length() < wordLength * num) return list;
        HashMap<String,Integer> hash = new HashMap<String,Integer>();
        for(int i = 0; i < L.length; i++){
            if(hash.containsKey(L[i])) hash.put(L[i],hash.get(L[i]) + 1);
            else hash.put(L[i],1);
        }
        HashMap<String,Integer> copy = new HashMap<String,Integer>(hash);
        for(int i = 0; i <= S.length() - wordLength; i++){
            int start = i;
            int end = start + wordLength;
            String sub = S.substring(start, end); 
            if(copy.get(sub)!=null && copy.get(sub) != 0){
                int count = 0;
                boolean canLoop = true;
                while(canLoop){
                    copy.put(S.substring(start, end), copy.get(S.substring(start, end)) - 1);
                    count++;
                    if(count == num){
                        list.add(i);
                        copy = (HashMap<String,Integer>)hash.clone();
                        break;
                    }
                    start = end;
                    end += wordLength;
                    if(end > S.length() || !copy.containsKey(S.substring(start, end)) || copy.get(S.subSequence(start, end).toString()) <= 0){
                        canLoop = false;
                        copy = (HashMap<String,Integer>)hash.clone();
                    }
                }
            }
        }
        return list;
    }
}

思路2：

优化，双指针法，思想类似 Longest Substring Without Repeating Characters， 复杂度可以达到线性。（待验证）

第二遍记录：

跟第一遍的思路1一样，代码也差不多：

public class Solution {
    public List<Integer> findSubstring(String s, String[] l) {
        List<Integer> res = new ArrayList<Integer>();
        if(l == null || l.length == 0 || s == null || s.length() < l.length * l[0].length())  return res;
        Map<String,Integer> map = new HashMap<String,Integer>();
        for(String str : l){
            if(map.get(str) == null){ 
                map.put(str,1);
            }else{ 
                map.put(str,map.get(str) + 1);
            }
        }
        Map<String,Integer> cpy = new HashMap<String,Integer>(map);
        int wordLength = l[0].length();
        for(int i = 0; i <= s.length() - wordLength * l.length; i++){
            String head = s.substring(i,i + wordLength);
            if(!cpy.containsKey(head)) continue;
            boolean valid = true;
            for(int j = 0; j < l.length; j++){
                String word = s.substring(i + j * wordLength, i + j * wordLength + wordLength);
                if(!cpy.containsKey(word) || cpy.get(word) == 0) {
                    valid = false;
                    cpy = new HashMap<String,Integer>(map);
                    break;
                }else{
                    cpy.put(word, cpy.get(word) - 1);
                }
            }
            if(valid){
                res.add(i);
                cpy = new HashMap<String,Integer>(map);
            }
        }
        return res;
    }
}

参考链接：

http://blog.csdn.net/ojshilu/article/details/22212703

http://blog.csdn.net/linhuanmars/article/details/20342851