leetcode算法【30】串联所有单词的子串

所有题目源代码：Git地址

题目

给定一个字符串 s 和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

 

示例 1：

输入：
  s = "barfoothefoobarman",
  words = ["foo","bar"]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。
示例 2：

输入：
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
输出：[]

方案

• 很惭愧，我自己写的方案，算是暴力破解，所以拿了一位大神的答案：传送门
• 思路是：巧妙地筛选大量非可能选项

假设words数组长度为L，word单词长度为WL,遍历字符串s, 下标记做i，
需要比对的单词起始坐标则为 [i, i+WL, i+2WL … i+(L-1)*WL]
如果i满足条件，各个单词的第k位之和一定相等
即：*words[0][k] + words[1][k] + … + words[L-1][k] == s[i + k] + s[i+WL + k] + … + s[i+(L-1)WL + k]
反之，若对于i，满足后者条件的i则可能为正确结果，这个时候直接校验即可。
总结：先找出符合特征的下标，再对符合下标的结果进行校验，完全符合则输出。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> rs = new ArrayList<>();
        if (words == null || words.length == 0) {
            return rs;
        }
        int wLen = words[0].length();
        int wTotalLen = words[0].length() * words.length;
        int sLen = s.length();
        int[] flagArray = new int[wLen];
        for (int i = 0; i < wLen; i++) {
            int flag = 0;
            for (String word : words) {
                flag += word.charAt(i);
            }
            flagArray[i] = flag;
        }

        BitSet bs = new BitSet(words.length);
        for (int i = 0; i <= sLen - wTotalLen; i++) {
            int j = 0;
            for (; j < wLen; j++) {
                int sumFlag = 0;
                for (int k = 0; k < words.length; k++) {
                    sumFlag += s.charAt(i + k * wLen + j);
                }
                if (sumFlag != flagArray[j]) {
                    break;
                }
            }
            if (j == wLen) {
                // 可能匹配
                bs.clear();
                for (int k = 0; k < words.length; k++) {
                    String w = s.substring(i + k * wLen, i + (k + 1) * wLen);
                    int n = 0;
                    for (; n < words.length; n++) {
                        if (!bs.get(n) && words[n].equals(w)) {
                            bs.set(n);
                            break;
                        }
                    }
                    if (n == words.length) {
                        break;
                    }
                }
                if (bs.cardinality() == words.length) {
                    rs.add(i);
                }

            }
        }

        return rs;
    }
}

复杂度计算

• 时间复杂度：O(mn)
• 空间复杂度：O(n)

杂记

• Bitset参考1
• Bitset参考2