LeetCode30. 串联所有单词的子串

给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

 s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。
返回所有串联字串在 s 中的开始索引。你可以以 任意顺序 返回答案。

示例 1：

输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。
示例 2：

输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出：[]
解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。
示例 3：

输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出：[6,9,12]
解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
 

提示：

1 <= s.length <= 104
1 <= words.length <= 5000
1 <= words[i].length <= 30
words[i] 和 s 由小写英文字母组成

主要的思路：判断每个子串是否符合，符合就把下标存起来，最后返回即可。

但是我们如何判断子串是否符合呢？我们需要两个Map来进行解决。首先我们在Map里面，key存储单词，value存储单词的个数。然后扫描子串的单词，如果当前扫描的单词在之前的 Map1中，就把该单词存到新的Map2 中，并判断新的Map2中该单词的value是不是大于之前的 Map1 该单词的value ，如果大了，就代表该子串不是我们要找的，接着判断下一个子串就可以了。如果不大于，那么我们接着判断下一个单词的情况。子串扫描结束，如果子串的全部单词都符合，那么该子串就是我们找的其中一个。

void main() {
  String s = "barfoothefoobarman";
  List words = ["foo", "bar"];
  print(findSubstring(s, words));
}

List findSubstring(String s, List words) {
  List result = [];
  if (s.length == 0 || words.length == 0) {
    return result;
  }
  Map wordsMap = {};
  // 字符串列表的长度
  int wordsLength = 0;
  for (int i = 0; i < words.length; i++) {
    // 字符串不包含字符串列表数据，直接return
    if (!s.contains(words[i])) {
      return result;
    }
    String word = words[i];
    wordsLength += word.length;
    // 存储单词出现的次数
    if (wordsMap[word] != null) {
      int temp = wordsMap[word] ?? 0;
      temp++;
      wordsMap[word] = temp;
    } else {
      wordsMap[word] = 1;
    }
  }
  // 字符串列表的长度 > 字符串长度，直接return
  if (wordsLength > s.length) {
    return result;
  }

  // 遍历所有子串
  for (int i = 0; i < s.length - wordsLength + 1; i++) {
    // 存储当前符合条件的单词
    Map hasWordsMap = {};
    int num = 0;
    while (num < words.length) {
      String word = s.substring(
          i + num * words[0].length, i + (num + 1) * words[0].length);
      // 判断单词是否在wordsMap中
      if (wordsMap.containsKey(word)) {
        // 存储单词出现的次数
        if (hasWordsMap[word] != null) {
          int temp = hasWordsMap[word] ?? 0;
          temp++;
          hasWordsMap[word] = temp;
        } else {
          hasWordsMap[word] = 1;
        }
        int wordNum = wordsMap[word] ?? 0;
        int hasWordNum = hasWordsMap[word] ?? 0;
        if (hasWordNum > wordNum) {
          break;
        }
      } else {
        break;
      }
      num++;
    }
    //判断是不是所有的单词都符合条件
    if (num == words.length) {
      result.add(i);
    }
  }
  return result;
}

LeetCode30. 串联所有单词的子串
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/substring-with-concatenation-of-all-words
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。