feat: 增加题解30.串联所有单词的子串

Author: suukii

README.md

@@ -119,11 +119,11 @@
 -   [x] [【day-20】347.前 K 个高频元素](./basic/hashmap/20.top-k-frequent-elements.md)
 -   [x] [【day-21】447.回旋镖的数量](./basic/hashmap/21.number-of-boomerangs.md)
 -   [x] [【day-22】3.无重复字符的最长子串](./basic/hashmap/22.longest-substring-without-repeating-characters.md)
+-   [x] [【day-23】30.串联所有单词的子串](./basic/hashmap/23.substring-with-concatenation-of-all-words.md)
 
 #### 哈希表拓展题目
 
 -   [x] [215.数组中的第 K 个最大元素](./basic/hashmap/ext-kth-largest-element-in-an-array.md)
-
 -   [ ] 36.有效的数独
 -   [x] [645.错误的集合](./basic/day-22.md)
 -   [x] [面试题 04.01.节点间通路](./basic/day-23.md)

basic/array-stack-queue/02.shortest-distance-to-a-character.md

@@ -1,6 +1,8 @@
 # 821.字符的最短距离
 
-- [821.字符的最短距离](#821dot字符的最短距离)
+https://leetcode-cn.com/problems/shortest-distance-to-a-character
+
+- [821.字符的最短距离](#821字符的最短距离)
   - [题目描述](#题目描述)
   - [解法 1：中心扩展法](#解法-1中心扩展法)
     - [思路](#思路)

basic/hashmap/23. substring-with-concatenation-of-all-words.md

@@ -0,0 +1,101 @@
+# 30. 串联所有单词的子串
+
+https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/
+
+- [30. 串联所有单词的子串](#30-串联所有单词的子串)
+  - [题目描述](#题目描述)
+  - [方法 1: 哈希表](#方法-1-哈希表)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+
+## 题目描述
+
+```
+给定一个字符串 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"]
+输出：[]
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+```
+
+## 方法 1: 哈希表
+
+### 思路
+
+naive 的想法是，将 words 里面的单词组合成字符串，然后到 s 里面去找有没有跟它一样的子串。但是，这样子时间复杂度太高了，因为 words 的组合有 `words.length!` 种，总复杂度差不多就是 `s.length * words.length!` 了。
+
+那我们反过来想，s 的子串最多只有 `s.length` 个，那我们只要判断 s 的每个子串是不是刚好由 words 数组里面的所有单词组成的就可以了。所以说，如果子串是刚好匹配 words 的单词的话，说明子串和 words 组成的字符串是两种组合情况，虽然排序不同，但包含的单词种类和数量是一样的。
+
+所以解决方法就很明显了：
+
+-   我们可以用哈希表来记录 words 里面有哪些单词，以及它们分别出现过几次(注意检查每个 s 子串时，哈希表都是新的)。
+-   然后开始遍历一个 s 的子串，将它截成一个个单词的长度，去哈希表中查询。
+-   如果出现在子串中的单词能在哈希表中找到，就将它的数量 -1，对消掉一个。
+-   如果这个单词在哈希表中找不到，或者数量已经变成了 0，就说明这个子串已经不符合我们的要求了，可以停止之后的比较了。
+-   如果子串的单词都比较完毕，然后哈希表中所有单词的数量也都刚好变成 0，就说明这个子串就是我们要找的。（这里到判断可以有多种，比如在开始子串比较之前用一个 count 变量来进行计数，如果子串比较结束后 count 刚好等于 words 的长度，就说明找到了符合要求的子串）
+-   接着换另一个子串，继续上述步骤。
+
+![](https://cdn.jsdelivr.net/gh/suukii/91-days-algorithm/assets/30_0.png)
+
+### 复杂度分析
+
+-   时间复杂度：$(n-k)*k$，n 是字符串 s 的长度，k 是单词的长度。
+-   空间复杂度：$m$，m 是 words 数组的长度，哈希表的空间。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number[]}
+ */
+var findSubstring = function (s, words) {
+    const wordSize = words[0].length;
+    const substringLen = wordSize * words.length;
+
+    const wordsCount = {};
+    words.forEach(w => (wordsCount[w] = (wordsCount[w] || 0) + 1));
+
+    const res = [];
+    for (let i = 0; i <= s.length - substringLen; i++) {
+        const tempCount = { ...wordsCount };
+        let count = words.length;
+
+        for (let j = i; j < i + substringLen; j += wordSize) {
+            const word = s.slice(j, j + wordSize);
+
+            if (!(word in tempCount) || tempCount[word] <= 0) break;
+
+            tempCount[word]--;
+            count--;
+        }
+
+        if (count === 0) res.push(i);
+    }
+    return res;
+};
+```