Leetcode 30 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 words exactly once and without any intervening characters.

Example 1:

Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input:
  s = "wordgoodstudentgoodword",
  words = ["word","student"]
Output: []

這個題目的意思是在原始串中找到連續子串的位置，注意每個子串的長度是唯一的。

1）

class Solution {
    public List<Integer> findSubstring(String S, String[] L) {
        List<Integer> result = new ArrayList<>();
        if (S == null || L == null || L.length == 0) return result;
        int size = L[0].length();
        if (L.length == 0 || L[0].isEmpty() || L[0].length() > S.length()) 
            return result;
        Map<String, Integer> hist = new HashMap<>();
        for (String w : L) {
            hist.put(w, !hist.containsKey(w) ? 1 : hist.get(w)+1);
        }
        for (int i = 0; i+size*L.length <= S.length(); i++) {
            if (hist.containsKey(S.substring(i, i+size))) {
                Map<String, Integer> currHist = new HashMap<>();
                for (int j = 0; j < L.length; j++) {
                    String word = S.substring(i+j*size, i+(j+1)*size);
                    currHist.put(word, !currHist.containsKey(word) ? 
                            1 : currHist.get(word)+1);
                }
                if (currHist.equals(hist)) result.add(i);
            }
        }
        return result;
    }
}

2）

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        int n = s.length(), m = words.length;
        List<Integer> result = new ArrayList<>();
        if (m == 0 || n == 0) return result;
        int l = words[0].length();                              //請注意，題目中說明了，每個word的長度是相同的
        
        Map<String, Integer> map = new HashMap<>();
        for (String w : words) {
            map.put(w, map.getOrDefault(w, 0) + 1);
        }
        
        for (int i = 0; i < l; i++) {          // 最初起點為 0,1,.... l-1 不用的offset
            for (int j = i; j + m * l <= n; j = j + l) {          // 確保整個substring長度不會超出
                String ss = s.substring(j, j + m * l);            // 拿到整個substring
                Map<String, Integer> temp = new HashMap<>();
                for (int k = m - 1; k >= 0; k--) {
                    String w = ss.substring(k * l, (k + 1) * l);
                    int count = temp.getOrDefault(w, 0) + 1;
                    
                    if (count > map.getOrDefault(w, 0)) {    // 這個是關鍵trick這也是為什麼要從末尾開始，break的時候可以把指標大幅向前
                        j = j + k * l;                    // 跳到當前check的下一個，因為父迴圈有 j = j+l,這裡只要 跳到check的那個就行了 j +k*l +l-l
                        //j = j+m*l-l;
                        break;
                    } else if (k == 0) {
                        result.add(j);
                    } else {
                        temp.put(w, count);
                    }
                }
            }
        }
        return result;        
    }

}