Substring

【LeetCode】

LC第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.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

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

这道题纠结了大半天，主要是题目要求是O(n)的解法，最容易想到的是下面这种暴力搜索的方法，会超时：

 

public static List<Integer> findSubstring(String S, String[] L) {
    List<Integer> res = new ArrayList<Integer>();
    if (S == null || L == null || L.length == 0) return res;
    int len = L[0].length(); // length of each word
    
    Map<String, Integer> map = new HashMap<String, Integer>(); // map for L
    for (String w : L) map.put(w, map.containsKey(w) ? map.get(w) + 1 : 1);
    
    for (int i = 0; i <= S.length() - len * L.length; i++) {
        Map<String, Integer> copy = new HashMap<String, Integer>(map);
        for (int j = 0; j < L.length; j++) { // checkc if match
            String str = S.substring(i + j*len, i + j*len + len); // next word
            if (copy.containsKey(str)) { // is in remaining words
                int count = copy.get(str);
                if (count == 1) copy.remove(str);
                else copy.put(str, count - 1);
                if (copy.isEmpty()) { // matches
                    res.add(i);
                    break;
                }
            } else break; // not in L
        }
    }
    return res;
}

然后发现了大家都会使用的所谓的移动窗口来匹配字符串的方法，这样可以保证复杂度为O(n)。

基本思路是维护一个窗口，如果当前单词在哈希中，则继续移动窗口右端，否则窗口左端可以跳到字符串下一个单词了。

而且这里的字符串数组的字符串长度是相同的，所以在写两层循环的时候注意循环停止条件。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        if(words == null || words.length == 0 || s == null || s.length() == 0)
            return res;
        int n = s.length(), wcl = words.length;
        HashMap<String, Integer> map = new HashMap<>();
        for(String word : words)
            map.put(word, map.containsKey(word) ? map.get(word) + 1 : 1);
        int wl = words[0].length();
        for(int i = 0; i < wl; i++){//注意循环终止条件
            int left = i, count = 0;
            HashMap<String, Integer> tmp = new HashMap<>(); //辅助哈希表
            for(int j = i; j <= n - wl; j += wl){
                String str = s.substring(j, j + wl);
                if(map.containsKey(str)){
                    if(tmp.containsKey(str))
                        tmp.put(str, tmp.get(str)+1);
                    else
                        tmp.put(str, 1);
                    if(tmp.get(str) <= map.get(str))
                        count++;
                    else{　　　　　　　　　　　　　　　　　　　　//add more word
                        while(tmp.get(str) > map.get(str)){
                            String str1 = s.substring(left, left + wl);
                            if(tmp.containsKey(str1)){
                                tmp.put(str1, tmp.get(str1)-1);
                                if(tmp.get(str1) < map.get(str1))// 只有在小于的时候count--，等于的时候相当于用后面的词替换了前面相同的词，count不变
                                    count--;
                            }
                            left += wl;
                        }
                    }
                    if(count == wcl){
                        res.add(left);
                        String str2 = s.substring(left, left + wl);  
                        if(tmp.containsKey(str2))  
                            tmp.put(str2, tmp.get(str2)-1);  
                        count--;  
                        left += wl; 
                    }
                }
                else{
                    tmp.clear();
                    count = 0;
                    left = j + wl;
                }
            }
        }
        return res;
    }
}

一道很类似的题目：76. Minimum Window Substring。

题目描述：

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"
Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

模仿上面一道题用两个哈希的写法，结果跑出了倒数10%的成绩。。。

class Solution {
    //模仿的Substring with Concatenation of All Words中的解法，用了两个哈希，结果跑了 66 ms。。。
    //别人都是用的数组，最快的只有3、4ms。。。
    public String minWindow(String s, String t) {
        String res = "";
        if(s.length() == 0 || t.length() == 0 || s.length() < t.length())
            return res;
        HashMap<Character, Integer> map = new HashMap<>();
        HashMap<Character, Integer> window = new HashMap<>();
        for (int i = 0; i < t.length(); i++){
            char c = t.charAt(i);
            map.put(c, map.containsKey(c) ? map.get(c) + 1 : 1);
        }
        int minLen = Integer.MAX_VALUE, count = 0;
        for(int slow = 0, fast = 0; fast < s.length(); fast++){
            char c = s.charAt(fast);
            if(map.containsKey(c)){
                if(window.containsKey(c))
                    window.put(c, window.get(c) + 1);
                else
                    window.put(c, 1);
                if(window.get(c) <= map.get(c))
                    count++;
            }
            if(count == t.length()){
                char cc = s.charAt(slow);
                while(!map.containsKey(cc) || window.get(cc) > map.get(cc)){
                    if(window.containsKey(cc))
                        window.put(cc, window.get(cc) - 1);
                    cc = s.charAt(++slow);
                }
                if(fast - slow + 1 < minLen){
                    minLen = fast - slow + 1;
                    res = s.substring(slow, slow + minLen);
                }
            }
        }
        return res;
    }
}

事实证明，这个地方用数组就可以解决问题，思想还是一样的移动窗口的思想，事实上，其实这个是子串或者字符串匹配很常用的思想，可以把复杂度降低到O(n)。

别人跑了4ms的代码：

class Solution {
    public String minWindow(String s, String t) {
        if (s == "" || t.length() > s.length()) {
            return "";
        }
        int[] map = new int[128];
        int start = 0, end = 0, count = t.length(), minStart = 0, minLen = Integer.MAX_VALUE;
        for (char ch : t.toCharArray()) {
            map[ch]++;
        }
        while (end < s.length()) {
            if (map[s.charAt(end)] > 0) {
                count--;
            }
            map[s.charAt(end)]--;
            end++;
            while (count == 0) {
                if (minLen > end - start) {
                    minLen = end - start;
                    minStart = start;
                }
                map[s.charAt(start)]++;
                if (map[s.charAt(start)] > 0) {
                    count++;
                }
                start++;
            }
        }
        return minLen == Integer.MAX_VALUE ? "" : s.substring(minStart, minStart + minLen);
    }
}