算法题解之滑动窗口

Substring with Concatenation of All Words

寻找所有词连接的子串

思路：由于该字串是所有词典中的词连接的，所以该字串长度固定。因此本题可以看作一个滑动窗口的题。为了去除重复工作，每次滑动一个单词的长度，因此起始位置就有n种（n为单词长度）。每种起始位置的滑动策略如下：

　　　如果当前窗口满足条件，则窗口只往后移动一个单词，并且下一次只检查最后一个单词（中间的单词肯定满足条件）。

　　   如果当前窗口不满足条件，则有两种情况：

　　　1.当前窗口内不满足条件的第一个单词不存在于词典中，则下一个窗口就直接滑到这个单词的下一个单词；

　　　2.当前窗口内不满足条件的第一个单词存在于词典中，但是这个单词已经被前面用完了，则下一个窗口只往后移动一个单词，并且下一次之间从这个单词开始检查。

public class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<Integer>();
        int m = words.length;
        int n = words[0].length();
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String word : words) {
            if (map.containsKey(word)) {
                map.put(word, map.get(word) + 1);
            } else {
                map.put(word, 1);
            }
        }
        for (int p = 0; p <= n - 1; p++) {
            int start = p;
            while (start + n * m - 1 < s.length()) {
                int i = 1;
                boolean moveOneWord = true;
                Map<String, Integer> copy = new HashMap<String, Integer>(map);
                while (moveOneWord && start + n * m - 1 < s.length()) {
                    for(; i <= m; i++) {
                        String cut = s.substring(start + (i - 1) * n, start + i * n);
                        if (copy.containsKey(cut)) {
                            if (copy.get(cut) == 0) {
                                moveOneWord = true;
                                break;
                            } else {
                                copy.put(cut, copy.get(cut) - 1);
                            }
                        } else {
                            start += i * n;
                            i = 1;
                            moveOneWord = false;
                            break;
                        }
                    }
                    
                    if (i == m + 1) {
                        res.add(start);
                        moveOneWord = true;
                    }
                    if (moveOneWord) {
                        String firstword = s.substring(start, start + n);
                        copy.put(firstword, copy.get(firstword) + 1);
                        start += n;
                        i--;
                    }
                }
            } 
        }
        return res;
    }
}