feat: add solutions to lc problem: No.1461

No.1461.Check If a String Contains All Binary Codes of Size K

Author: yanglbme

solution/0700-0799/0782.Transform to Chessboard/Solution.py

@@ -29,7 +29,10 @@ def f(mask, cnt):
             for j in range(n):
                 curRowMask |= board[i][j] << j
                 curColMask |= board[j][i] << j
-            if curRowMask not in (rowMask, revRowMask) or curColMask not in (colMask, revColMask):
+            if curRowMask not in (rowMask, revRowMask) or curColMask not in (
+                colMask,
+                revColMask,
+            ):
                 return -1
             sameRow += curRowMask == rowMask
             sameCol += curColMask == colMask

solution/1300-1399/1339.Maximum Product of Splitted Binary Tree/Solution.py

@@ -23,5 +23,5 @@ def dfs(root):
         s = sum(root)
         ans = 0
         dfs(root)
-        ans %= (10**9 + 7)
+        ans %= 10**9 + 7
         return ans

solution/1400-1499/1460.Make Two Arrays Equal by Reversing Sub-arrays/README.md

@@ -57,7 +57,7 @@
 
 **前言**
 
-由于我们可以对 $arr$ 任意非空子数组进行翻转，也就意味着我们可以交换任何两个相邻元素，使得数组按特定的一种顺序排列。
+由于我们可以对 $arr$ 任意非空子数组进行翻转，也就意味着我们可以交换任意两个相邻元素，使得数组按特定的一种顺序排列。
 
 因此，题目转换为：判断一个数组是否是另一个数组的排列。
 
@@ -69,9 +69,9 @@
 
 **方法二：数组/哈希表**
 
-由于两数组的数据范围都是 $1 \leq x \leq 1000$，因此我们可以使用数组/哈希表来记录每个数字出现的次数。
+由于两数组的数据范围都是 $1 \leq x \leq 1000$，因此我们可以使用数组或哈希表来记录每个数字出现的次数。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 是数组 $arr$ 的长度，而 $C$ 是数组 $arr$ 元素的值域大小。
 
 <!-- tabs:start -->
 
@@ -93,6 +93,16 @@ class Solution:
         return Counter(target) == Counter(arr)
 ```
 
+```python
+class Solution:
+    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
+        cnt = [0] * 1001
+        for a, b in zip(target, arr):
+            cnt[a] += 1
+            cnt[b] -= 1
+        return all(v == 0 for v in cnt)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -123,6 +133,23 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean canBeEqual(int[] target, int[] arr) {
+        int[] cnt = new int[1001];
+        for (int v : target) {
+            ++cnt[v];
+        }
+        for (int v : arr) {
+            if (--cnt[v] < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -149,6 +176,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    bool canBeEqual(vector<int>& target, vector<int>& arr) {
+        vector<int> cnt(1001);
+        for (int& v : target) ++cnt[v];
+        for (int& v : arr) if (--cnt[v] < 0) return false;
+        return true;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -183,6 +222,22 @@ func canBeEqual(target []int, arr []int) bool {
 }
 ```
 
+```go
+func canBeEqual(target []int, arr []int) bool {
+	cnt := make([]int, 1001)
+	for _, v := range target {
+		cnt[v]++
+	}
+	for _, v := range arr {
+		cnt[v]--
+		if cnt[v] < 0 {
+			return false
+		}
+	}
+	return true
+}
+```
+
 ### **C**
 
 ```c

solution/1400-1499/1460.Make Two Arrays Equal by Reversing Sub-arrays/README_EN.md

@@ -67,6 +67,16 @@ class Solution:
         return Counter(target) == Counter(arr)
 ```
 
+```python
+class Solution:
+    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
+        cnt = [0] * 1001
+        for a, b in zip(target, arr):
+            cnt[a] += 1
+            cnt[b] -= 1
+        return all(v == 0 for v in cnt)
+```
+
 ### **Java**
 
 ```java
@@ -95,6 +105,23 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean canBeEqual(int[] target, int[] arr) {
+        int[] cnt = new int[1001];
+        for (int v : target) {
+            ++cnt[v];
+        }
+        for (int v : arr) {
+            if (--cnt[v] < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -121,6 +148,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    bool canBeEqual(vector<int>& target, vector<int>& arr) {
+        vector<int> cnt(1001);
+        for (int& v : target) ++cnt[v];
+        for (int& v : arr) if (--cnt[v] < 0) return false;
+        return true;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -155,6 +194,22 @@ func canBeEqual(target []int, arr []int) bool {
 }
 ```
 
+```go
+func canBeEqual(target []int, arr []int) bool {
+	cnt := make([]int, 1001)
+	for _, v := range target {
+		cnt[v]++
+	}
+	for _, v := range arr {
+		cnt[v]--
+		if cnt[v] < 0 {
+			return false
+		}
+	}
+	return true
+}
+```
+
 ### **C**
 
 ```c

solution/1400-1499/1461.Check If a String Contains All Binary Codes of Size K/README.md

@@ -48,7 +48,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-遍历字符串 s，用一个 set 存储所有长度为 k 的不同子串。只需要判断子串数能否达到 2<sup>k</sup> 即可。
+**方法一：哈希表**
+
+遍历字符串 $s$，用一个哈希表存储所有长度为 $k$ 的不同子串。只需要判断子串数能否达到 $2^k$ 即可。
+
+时间复杂度 $O(n \ times k)$，其中 $n$ 是字符串 $s$ 的长度，$k$ 是子串长度。
+
+**方法二：滑动窗口**
+
+方法一中，我们存储了所有长度为 $k$ 的不同子串，子串的处理需要 $O(k)$ 的时间，我们可以改用滑动窗口，每次添加最新字符时，删除窗口最左边的字符。此过程中用一个整型数字 $num$ 来存放子串。
+
+时间复杂度 $O(n)$，其中 $n$ 是字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
@@ -59,15 +69,24 @@
 ```python
 class Solution:
     def hasAllCodes(self, s: str, k: int) -> bool:
-        counter = 1 << k
-        exists = set()
-        for i in range(k, len(s) + 1):
-            if s[i - k : i] not in exists:
-                exists.add(s[i - k : i])
-                counter -= 1
-            if counter == 0:
-                return True
-        return False
+        ss = {s[i: i + k] for i in range(len(s) - k + 1)}
+        return len(ss) == 1 << k
+```
+
+```python
+class Solution:
+    def hasAllCodes(self, s: str, k: int) -> bool:
+        if len(s) - k + 1 < (1 << k):
+            return False
+        vis = [False] * (1 << k)
+        num = int(s[:k], 2)
+        vis[num] = True
+        for i in range(k, len(s)):
+            a = (ord(s[i - k]) - ord('0')) << (k - 1)
+            b = ord(s[i]) - ord('0')
+            num = ((num - a) << 1) + b
+            vis[num] = True
+        return all(v for v in vis)
 ```
 
 ### **Java**
@@ -77,20 +96,112 @@ class Solution:
 ```java
 class Solution {
     public boolean hasAllCodes(String s, int k) {
-        int counter = 1 << k;
-        Set<String> exists = new HashSet<>();
-        for (int i = k; i <= s.length(); ++i) {
-            String t = s.substring(i - k, i);
-            if (!exists.contains(t)) {
-                exists.add(t);
-                --counter;
-            }
-            if (counter == 0) {
-                return true;
+        Set<String> ss = new HashSet<>();
+        for (int i = 0; i < s.length() - k + 1; ++i) {
+            ss.add(s.substring(i, i + k));
+        }
+        return ss.size() == 1 << k;
+    }
+}
+```
+
+```java
+class Solution {
+    public boolean hasAllCodes(String s, int k) {
+        int n = s.length();
+        if (n - k + 1 < (1 << k)) {
+            return false;
+        }
+        boolean[] vis = new boolean[1 << k];
+        int num = Integer.parseInt(s.substring(0, k), 2);
+        vis[num] = true;
+        for (int i = k; i < n; ++i) {
+            int a = (s.charAt(i - k) - '0') << (k - 1);
+            int b = s.charAt(i) - '0';
+            num = (num - a) << 1 | b;
+            vis[num] = true;
+        }
+        for (boolean v : vis) {
+            if (!v) {
+                return false;
             }
         }
-        return false;
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool hasAllCodes(string s, int k) {
+        unordered_set<string> ss;
+        for (int i = 0; i + k <= s.size(); ++i) {
+            ss.insert(move(s.substr(i, k)));
+        }
+        return ss.size() == 1 << k;
     }
+};
+```
+
+```cpp
+class Solution {
+public:
+    bool hasAllCodes(string s, int k) {
+        int n = s.size();
+        if (n - k + 1 < (1 << k)) return false;
+        vector<bool> vis(1 << k);
+        int num = stoi(s.substr(0, k), nullptr, 2);
+        vis[num] = true;
+        for (int i = k; i < n; ++i) {
+            int a = (s[i - k] - '0') << (k - 1);
+            int b = s[i] - '0';
+            num = (num - a) << 1 | b;
+            vis[num] = true;
+        }
+        for (bool v : vis) if (!v) return false;
+        return true;
+    }
+};
+```
+
+### **Go**
+
+```go
+func hasAllCodes(s string, k int) bool {
+	ss := map[string]bool{}
+	for i := 0; i+k <= len(s); i++ {
+		ss[s[i:i+k]] = true
+	}
+	return len(ss) == 1<<k
+}
+```
+
+```go
+func hasAllCodes(s string, k int) bool {
+	n := len(s)
+	if n-k+1 < (1 << k) {
+		return false
+	}
+	vis := make([]bool, 1<<k)
+	num := 0
+	for i := 0; i < k; i++ {
+		num = num<<1 | int(s[i]-'0')
+	}
+	vis[num] = true
+	for i := k; i < n; i++ {
+		a := int(s[i-k]-'0') << (k - 1)
+		num = (num-a)<<1 | int(s[i]-'0')
+		vis[num] = true
+	}
+	for _, v := range vis {
+		if !v {
+			return false
+		}
+	}
+	return true
 }
 ```