feat: add solutions to lc problem: No.0030

No.0030.Substring with Concatenation of All Words

Author: yanglbme

solution/0000-0099/0030.Substring with Concatenation of All Words/README.md

@@ -66,6 +66,14 @@ s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接
 
 **方法一：哈希表 + 滑动窗口**
 
+我们用哈希表 $cnt$ 统计 $words$ 中每个单词出现的次数，用哈希表 $cnt1$ 统计当前滑动窗口中每个单词出现的次数。我们记字符串 $s$ 的长度为 $m$，字符串数组 $words$ 中单词的数量为 $n$，每个单词的长度为 $k$。
+
+我们可以枚举滑动窗口的起点 $i$，其中 $0 \lt i \lt k$。对于每个起点，我们维护一个滑动窗口，左边界为 $l$，右边界为 $r$，滑动窗口中的单词个数为 $t$，另外用一个哈希表 $cnt1$ 统计滑动窗口中每个单词出现的次数。
+
+每一次，我们提取字符串 $s[r:r+k]$，如果 $s[r:r+k]$ 不在哈希表 $cnt$ 中，说明当前滑动窗口中的单词不合法，我们将左边界 $l$ 更新为 $r$，同时将哈希表 $cnt1$ 清空，单词个数 $t$ 重置为 0。如果 $s[r:r+k]$ 在哈希表 $cnt$ 中，说明当前滑动窗口中的单词合法，我们将单词个数 $t$ 加 1，将哈希表 $cnt1$ 中 $s[r:r+k]$ 的次数加 1。如果 $cnt1[s[r:r+k]]$ 大于 $cnt[s[r:r+k]]$，说明当前滑动窗口中 $s[r:r+k]$ 出现的次数过多，我们需要将左边界 $l$ 右移，直到 $cnt1[s[r:r+k]] = cnt[s[r:r+k]]$。如果 $t = n$，说明当前滑动窗口中的单词正好合法，我们将左边界 $l$ 加入答案数组。
+
+时间复杂度 $O(m \times k)$，空间复杂度 $O(n \times k)$。其中 $m$ 和 $n$ 分别是字符串 $s$ 和字符串数组 $words$ 的长度，而 $k$ 是字符串数组 $words$ 中单词的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -76,16 +84,16 @@ s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接
 class Solution:
     def findSubstring(self, s: str, words: List[str]) -> List[int]:
         cnt = Counter(words)
-        sublen = len(words[0])
-        n, m = len(s), len(words)
+        m, n = len(s), len(words)
+        k = len(words[0])
         ans = []
-        for i in range(sublen):
+        for i in range(k):
             cnt1 = Counter()
             l = r = i
             t = 0
-            while r + sublen <= n:
-                w = s[r : r + sublen]
-                r += sublen
+            while r + k <= m:
+                w = s[r: r + k]
+                r += k
                 if w not in cnt:
                     l = r
                     cnt1.clear()
@@ -94,11 +102,11 @@ class Solution:
                 cnt1[w] += 1
                 t += 1
                 while cnt1[w] > cnt[w]:
-                    remove = s[l : l + sublen]
-                    l += sublen
+                    remove = s[l: l + k]
+                    l += k
                     cnt1[remove] -= 1
                     t -= 1
-                if m == t:
+                if t == n:
                     ans.append(l)
         return ans
 ```
@@ -112,33 +120,33 @@ class Solution {
     public List<Integer> findSubstring(String s, String[] words) {
         Map<String, Integer> cnt = new HashMap<>();
         for (String w : words) {
-            cnt.put(w, cnt.getOrDefault(w, 0) + 1);
+            cnt.merge(w, 1, Integer::sum);
         }
-        int subLen = words[0].length();
-        int n = s.length(), m = words.length;
+        int m = s.length(), n = words.length;
+        int k = words[0].length();
         List<Integer> ans = new ArrayList<>();
-        for (int i = 0; i < subLen; ++i) {
+        for (int i = 0; i < k; ++i) {
             Map<String, Integer> cnt1 = new HashMap<>();
             int l = i, r = i;
             int t = 0;
-            while (r + subLen <= n) {
-                String w = s.substring(r, r + subLen);
-                r += subLen;
+            while (r + k <= m) {
+                String w = s.substring(r, r + k);
+                r += k;
                 if (!cnt.containsKey(w)) {
-                    l = r;
                     cnt1.clear();
+                    l = r;
                     t = 0;
                     continue;
                 }
-                cnt1.put(w, cnt1.getOrDefault(w, 0) + 1);
+                cnt1.merge(w, 1, Integer::sum);
                 ++t;
                 while (cnt1.get(w) > cnt.get(w)) {
-                    String remove = s.substring(l, l + subLen);
-                    l += subLen;
-                    cnt1.put(remove, cnt1.get(remove) - 1);
+                    String remove = s.substring(l, l + k);
+                    l += k;
+                    cnt1.merge(remove, -1, Integer::sum);
                     --t;
                 }
-                if (m == t) {
+                if (t == n) {
                     ans.add(l);
                 }
             }
@@ -155,32 +163,35 @@ class Solution {
 public:
     vector<int> findSubstring(string s, vector<string>& words) {
         unordered_map<string, int> cnt;
-        for (auto& w : words) cnt[w]++;
-        int subLen = words[0].size();
-        int n = s.size(), m = words.size();
+        for (auto& w : words) {
+            ++cnt[w];
+        }
+        int m = s.size(), n = words.size(), k = words[0].size();
         vector<int> ans;
-        for (int i = 0; i < subLen; ++i) {
+        for (int i = 0; i < k; ++i) {
             unordered_map<string, int> cnt1;
             int l = i, r = i;
             int t = 0;
-            while (r + subLen <= n) {
-                string w = s.substr(r, subLen);
-                r += subLen;
+            while (r + k <= m) {
+                string w = s.substr(r, k);
+                r += k;
                 if (!cnt.count(w)) {
+                    cnt1.clear();
                     l = r;
                     t = 0;
-                    cnt1.clear();
                     continue;
                 }
-                cnt1[w]++;
-                t++;
+                ++cnt1[w];
+                ++t;
                 while (cnt1[w] > cnt[w]) {
-                    string remove = s.substr(l, subLen);
-                    l += subLen;
-                    cnt1[remove]--;
+                    string remove = s.substr(l, k);
+                    l += k;
+                    --cnt1[remove];
                     --t;
                 }
-                if (t == m) ans.push_back(l);
+                if (t == n) {
+                    ans.push_back(l);
+                }
             }
         }
         return ans;
@@ -219,41 +230,36 @@ public:
 ### **Go**
 
 ```go
-func findSubstring(s string, words []string) []int {
+func findSubstring(s string, words []string) (ans []int) {
 	cnt := map[string]int{}
 	for _, w := range words {
 		cnt[w]++
 	}
-	subLen := len(words[0])
-	n, m := len(s), len(words)
-	var ans []int
-	for i := 0; i < subLen; i++ {
+	m, n, k := len(s), len(words), len(words[0])
+	for i := 0; i < k; i++ {
 		cnt1 := map[string]int{}
-		l, r := i, i
-		t := 0
-		for r+subLen <= n {
-			w := s[r : r+subLen]
-			r += subLen
+		l, r, t := i, i, 0
+		for r+k <= m {
+			w := s[r : r+k]
+			r += k
 			if _, ok := cnt[w]; !ok {
-				l = r
-				t = 0
+				l, t = r, 0
 				cnt1 = map[string]int{}
 				continue
 			}
 			cnt1[w]++
 			t++
 			for cnt1[w] > cnt[w] {
-				remove := s[l : l+subLen]
-				l += subLen
-				cnt1[remove]--
+				cnt1[s[l:l+k]]--
+				l += k
 				t--
 			}
-			if t == m {
+			if t == n {
 				ans = append(ans, l)
 			}
 		}
 	}
-	return ans
+	return
 }
 ```
 
@@ -262,56 +268,87 @@ func findSubstring(s string, words []string) []int {
 ```cs
 public class Solution {
     public IList<int> FindSubstring(string s, string[] words) {
-        var wordsDict = new Dictionary<string, int>();
-        foreach (var word in words)
-        {
-            if (!wordsDict.ContainsKey(word))
-            {
-                wordsDict.Add(word, 1);
-            }
-            else
-            {
-                ++wordsDict[word];
+        var cnt = new Dictionary<string, int>();
+        foreach (var w in words) {
+            if (!cnt.ContainsKey(w)) {
+                cnt[w] = 0;
             }
+            ++cnt[w];
         }
-
-        var wordOfS = new string[s.Length];
-        var wordLength = words[0].Length;
-        var wordCount = words.Length;
-        for (var i = 0; i <= s.Length - wordLength; ++i)
-        {
-            var substring = s.Substring(i, wordLength);
-            if (wordsDict.ContainsKey(substring))
-            {
-                wordOfS[i] = substring;
+        int m = s.Length, n = words.Length, k = words[0].Length;
+        var ans = new List<int>();
+        for (int i = 0; i < k; ++i) {
+            var cnt1 = new Dictionary<string, int>();
+            int l = i, r = i, t = 0;
+            while (r + k <= m) {
+                var w = s.Substring(r, k);
+                r += k;
+                if (!cnt.ContainsKey(w)) {
+                    cnt1.Clear();
+                    t = 0;
+                    l = r;
+                    continue;
+                }
+                if (!cnt1.ContainsKey(w)) {
+                    cnt1[w] = 0;
+                }
+                ++cnt1[w];
+                ++t;
+                while (cnt1[w] > cnt[w]) {
+                    --cnt1[s.Substring(l, k)];
+                    l += k;
+                    --t;
+                }
+                if (t == n) {
+                    ans.Add(l);
+                }
             }
         }
+        return ans;
+    }
+}
+```
 
-        var result = new List<int>();
-        for (var i = 0; i <= s.Length - wordLength * wordCount; ++i)
-        {
-            var tempDict = new Dictionary<string, int>(wordsDict);
-            var tempCount = 0;
-            for (var j = i; j <= i + wordLength * (wordCount - 1); j += wordLength)
-            {
-                if (wordOfS[j] != null && tempDict[wordOfS[j]] > 0)
-                {
-                    --tempDict[wordOfS[j]];
-                    ++tempCount;
-                }
-                else
-                {
-                    break;
-                }
+### **TypeScript**
+
+```ts
+function findSubstring(s: string, words: string[]): number[] {
+    const cnt: Map<string, number> = new Map();
+    for (const w of words) {
+        cnt.set(w, (cnt.get(w) || 0) + 1);
+    }
+    const m = s.length;
+    const n = words.length;
+    const k = words[0].length;
+    const ans: number[] = [];
+    for (let i = 0; i < k; ++i) {
+        const cnt1: Map<string, number> = new Map();
+        let l = i;
+        let r = i;
+        let t = 0;
+        while (r + k <= m) {
+            const w = s.slice(r, r + k);
+            r += k;
+            if (!cnt.has(w)) {
+                cnt1.clear();
+                l = r;
+                t = 0;
+                continue;
             }
-            if (tempCount == wordCount)
-            {
-                result.Add(i);
+            cnt1.set(w, (cnt1.get(w) || 0) + 1);
+            ++t;
+            while (cnt1.get(w)! - cnt.get(w)! > 0) {
+                const remove = s.slice(l, l + k);
+                cnt1.set(remove, cnt1.get(remove)! - 1);
+                l += k;
+                --t;
+            }
+            if (t === n) {
+                ans.push(l);
             }
         }
-
-        return result;
     }
+    return ans;
 }
 ```