周赛 477

Author: EndlessCheng

leetcode/weekly/477/README.md

@@ -1,10 +1,11 @@
 # 力扣周赛 477 题解 - 灵茶山艾府 - 灵神
 
 【题单+刷题路线】https://leetcode.cn/circle/discuss/RvFUtj/
+
 本场比赛题解 + Python/Java/C++/Go 代码：
-Q1 https://leetcode.cn/problems/concatenate-non-zero-digits-and-multiply-by-sum-i/solution/bu-yong-zi-fu-chuan-de-zuo-fa-pythonjava-0pai/
-Q2 https://leetcode.cn/problems/find-maximum-balanced-xor-subarray-length/solution/qian-zhui-he-yu-ha-xi-biao-pythonjavacgo-2504/
-Q3 https://leetcode.cn/problems/concatenate-non-zero-digits-and-multiply-by-sum-ii/solution/san-ge-qian-zhui-he-pythonjavacgo-by-end-6e1a/
-Q4 https://leetcode.cn/problems/number-of-effective-subsequences/solution/zheng-nan-ze-fan-rong-chi-yuan-li-sos-dp-abir/
+- Q1 https://leetcode.cn/problems/concatenate-non-zero-digits-and-multiply-by-sum-i/solution/bu-yong-zi-fu-chuan-de-zuo-fa-pythonjava-0pai/
+- Q2 https://leetcode.cn/problems/find-maximum-balanced-xor-subarray-length/solution/qian-zhui-he-yu-ha-xi-biao-pythonjavacgo-2504/
+- Q3 https://leetcode.cn/problems/concatenate-non-zero-digits-and-multiply-by-sum-ii/solution/san-ge-qian-zhui-he-pythonjavacgo-by-end-6e1a/
+- Q4 https://leetcode.cn/problems/number-of-effective-subsequences/solution/zheng-nan-ze-fan-rong-chi-yuan-li-sos-dp-abir/
 
-[本题视频讲解](https://www.bilibili.com/video/TODO时间/?t=2m30s)，欢迎点赞关注~
+[本题视频讲解](https://www.bilibili.com/video/BV1arUKBbEks/)，欢迎点赞关注~

leetcode/weekly/477/a/README.md

@@ -2,7 +2,7 @@
 
 对于不为零的数位 $d$，通过 $d\cdot 10^k$ 组合起来，其中 $k$ 是当前 $x$ 的十进制长度。$k$ 从 $0$ 开始，每添加一个数位就加一。
 
-下午两点 [B站@灵茶山艾府](https://space.bilibili.com/206214) 直播讲题，欢迎关注~
+[本题视频讲解](https://www.bilibili.com/video/BV1arUKBbEks/?t=48m9s)，欢迎点赞关注~
 
 ```py [sol-Python3]
 class Solution:

leetcode/weekly/477/b/README.md

@@ -20,8 +20,6 @@ $s[r]\oplus s[l] = 0$ 意味着 $s[r] = s[l]$。
 - 如果在哈希表中查询到二元组，那么用当前下标减去哈希表中保存的下标，即为子数组长度，更新答案的最大值。
 - 否则，把二元组及当前下标保存到哈希表中。
 
-下午两点 [B站@灵茶山艾府](https://space.bilibili.com/206214) 直播讲题，欢迎关注~
-
 ```py [sol-Python3]
 class Solution:
  def maxBalancedSubarray(self, nums: List[int]) -> int:
@@ -120,7 +118,7 @@ func maxBalancedSubarray(nums []int) (ans int) {
 
 ## 专题训练
 
-见下面动态规划题单的「**§1.2 前缀和与哈希表**」。
+见下面数据结构题单的「**§1.2 前缀和与哈希表**」。
 
 ## 分类题单
 

leetcode/weekly/477/c/README.md

@@ -8,9 +8,9 @@
 
 我们可以先计算 $s$ 的每个前缀（包括空前缀）对应的数字，即 $\textit{preNum} = [0,1,12,123,1234,12345]$。
 
-想一想，如何得到 $34$？
+想一想，如何从这些数中得到 $34$？
 
-我们可以计算 $1234 - 12\cdot 10^2 = 1234-1200 = 34$。其中 $2$ 是子串的长度。
+我们可以计算 $1234 - 12\cdot 10^2 = 1234-1200 = 34$。其中 $2$ 是子串 $34$ 的长度。
 
 一般地，子串 $[l,r]$ 对应的数字为
 
@@ -22,11 +22,11 @@ $$
 
 这意味着我们还需要计算子串中的非零字符个数，代替上式中的 $r-l+1$。
 
-维护把非零字符视作 $1$，计算其前缀和。
+把 $s$ 中的非零字符视作 $1$，计算其前缀和。
 
-注意取模，原理见 [模运算的世界：当加减乘除遇上取模](https://leetcode.cn/circle/discuss/mDfnkW/)。
+代码实现时，注意取模。为什么可以在中途取模？原理见 [模运算的世界：当加减乘除遇上取模](https://leetcode.cn/circle/discuss/mDfnkW/)。
 
-下午两点 [B站@灵茶山艾府](https://space.bilibili.com/206214) 直播讲题，欢迎关注~
+[本题视频讲解](https://www.bilibili.com/video/BV1arUKBbEks/?t=52m5s)，欢迎点赞关注~
 
 ```py [sol-Python3]
 MOD = 1_000_000_007
@@ -40,17 +40,17 @@ for i in range(1, MAX_N):
 class Solution:
  def sumAndMultiply(self, s: str, queries: List[List[int]]) -> List[int]:
  n = len(s)
- sum_d = [0] * (n + 1) # s 的前缀和
- pre_num = [0] * (n + 1) # s 的前缀对应的数字（模 MOD）
- sum_non_zero = [0] * (n + 1) # s 的前缀的非零数字个数
+ sum_d = [0] * (n + 1)  # s 的前缀和
+ pre_num = [0] * (n + 1)  # s 的前缀对应的数字（模 MOD）
+ sum_non_zero = [0] * (n + 1) # s 的前缀中的非零数字个数
  for i, d in enumerate(map(int, s)):
  sum_d[i + 1] = sum_d[i] + d
  pre_num[i + 1] = (pre_num[i] * 10 + d) % MOD if d else pre_num[i]
  sum_non_zero[i + 1] = sum_non_zero[i] + (d > 0)
 
  ans = []
  for l, r in queries:
- r += 1 # 注意这里把 r 加一了
+ r += 1 # 避免下面多次计算 r+1
  length = sum_non_zero[r] - sum_non_zero[l]
  x = pre_num[r] - pre_num[l] * pow10[length]
  ans.append(x * (sum_d[r] - sum_d[l]) % MOD)
@@ -62,8 +62,15 @@ class Solution {
  private static final int MOD = 1_000_000_007;
  private static final int MAX_N = 100_001;
  private static final int[] pow10 = new int[MAX_N];
+ private static boolean initialized = false;
+
+ // 这样写比 static block 快
+ private void init() {
+ if (initialized) {
+ return;
+ }
+ initialized = true;
 
- static {
  // 预处理 10 的幂
  pow10[0] = 1;
  for (int i = 1; i < MAX_N; i++) {
@@ -72,24 +79,26 @@ class Solution {
  }
 
  public int[] sumAndMultiply(String s, int[][] queries) {
+ init();
+
  int n = s.length();
  int[] sumD = new int[n + 1]; // s 的前缀和
  int[] preNum = new int[n + 1]; // s 的前缀对应的数字（模 mod）
- int[] sumNonZero = new int[n + 1]; // s 的前缀的非零数字个数
+ int[] sumNonZero = new int[n + 1]; // s 的前缀中的非零数字个数
  for (int i = 0; i < n; i++) {
  int d = s.charAt(i) - '0';
- sumD[i + 1] = sumD[i] + d; // s 的前缀和
- preNum[i + 1] = d > 0 ? (int) ((preNum[i] * 10L + d) % MOD) : preNum[i]; // s 的前缀对应的数字（模 MOD）
- sumNonZero[i + 1] = sumNonZero[i] + (d > 0 ? 1 : 0); // s 的前缀的非零数字个数
+ sumD[i + 1] = sumD[i] + d;
+ preNum[i + 1] = d > 0 ? (int) ((preNum[i] * 10L + d) % MOD) : preNum[i];
+ sumNonZero[i + 1] = sumNonZero[i] + (d > 0 ? 1 : 0);
  }
 
  int[] ans = new int[queries.length];
  for (int i = 0; i < queries.length; i++) {
  int l = queries[i][0];
- int r = queries[i][1] + 1; // 注意这里把 r 加一了
+ int r = queries[i][1] + 1; // 注意这里已经把 r 加一了
  int length = sumNonZero[r] - sumNonZero[l];
- long x = preNum[r] - (long) preNum[l] * pow10[length] % MOD; // 注意结果可能是负数，所以下面 +MOD
- ans[i] = (int) ((x + MOD) * (sumD[r] - sumD[l]) % MOD);
+ long x = preNum[r] - (long) preNum[l] * pow10[length] % MOD + MOD; // +MOD 保证结果非负
+ ans[i] = (int) (x * (sumD[r] - sumD[l]) % MOD);
  }
  return ans;
  }
@@ -119,16 +128,16 @@ public:
  int d = s[i] - '0';
  sum_d[i + 1] = sum_d[i] + d; // s 的前缀和
  pre_num[i + 1] = d > 0 ? (pre_num[i] * 10LL + d) % MOD : pre_num[i]; // s 的前缀对应的数字（模 MOD）
- sum_non_zero[i + 1] = sum_non_zero[i] + (d > 0); // s 的前缀的非零数字个数
+ sum_non_zero[i + 1] = sum_non_zero[i] + (d > 0); // s 的前缀中的非零数字个数
  }
 
   vector<int> ans;
   ans.reserve(queries.size()); // 预分配空间
   for (auto& q : queries) {
-  int l = q[0], r = q[1] + 1; // 注意这里把 r 加一了
+  int l = q[0], r = q[1] + 1; // 注意这里已经把 r 加一了
   int length = sum_non_zero[r] - sum_non_zero[l];
-  long long x = pre_num[r] - 1LL * pre_num[l] * pow10[length] % MOD; // 注意结果可能是负数，所以下面 +mod
-  ans.push_back((x + MOD) * (sum_d[r] - sum_d[l]) % MOD);
+  long long x = pre_num[r] - 1LL * pre_num[l] * pow10[length] % MOD + MOD; // +MOD 保证结果非负
+  ans.push_back(x * (sum_d[r] - sum_d[l]) % MOD);
   }
  return ans;
  }
@@ -152,7 +161,7 @@ func sumAndMultiply(s string, queries [][]int) []int {
 n := len(s)
 sumD := make([]int, n+1) // s 的前缀和
 preNum := make([]int, n+1) // s 的前缀对应的数字（模 mod）
-sumNonZero := make([]int, n+1) // s 的前缀的非零数字个数
+sumNonZero := make([]int, n+1) // s 的前缀中的非零数字个数
 for i, ch := range s {
 d := int(ch - '0')
 sumD[i+1] = sumD[i] + d
@@ -168,8 +177,8 @@ func sumAndMultiply(s string, queries [][]int) []int {
 for i, q := range queries {
 l, r := q[0], q[1]+1
 length := sumNonZero[r] - sumNonZero[l]
-x := preNum[r] - preNum[l]*pow10[length]%mod // 注意结果可能是负数，所以下面 +mod
-ans[i] = (x + mod) * (sumD[r] - sumD[l]) % mod
+x := preNum[r] - preNum[l]*pow10[length]%mod + mod // +mod 保证结果非负
+ans[i] = x * (sumD[r] - sumD[l]) % mod
 }
 return ans
 }
@@ -182,6 +191,10 @@ func sumAndMultiply(s string, queries [][]int) []int {
 - 时间复杂度：$\mathcal{O}(n+q)$，其中 $n$ 是 $\textit{nums}$ 的长度，$q$ 是 $\textit{queries}$ 的长度。
 - 空间复杂度：$\mathcal{O}(n)$。返回值不计入。
 
+## 相似题目
+
+[2156. 查找给定哈希值的子串](https://leetcode.cn/problems/find-substring-with-given-hash-value/)
+
 ## 专题训练
 
 见下面数据结构题单的「**一、前缀和**」。

leetcode/weekly/477/c/c.go

@@ -17,7 +17,7 @@ func sumAndMultiply(s string, queries [][]int) []int {
 n := len(s)
 sumD := make([]int, n+1) // s 的前缀和
 preNum := make([]int, n+1) // s 的前缀对应的数字（模 mod）
-sumNonZero := make([]int, n+1) // s 的前缀的非零数字个数
+sumNonZero := make([]int, n+1) // s 的前缀中的非零数字个数
 for i, ch := range s {
 d := int(ch - '0')
 sumD[i+1] = sumD[i] + d
@@ -33,8 +33,8 @@ func sumAndMultiply(s string, queries [][]int) []int {
 for i, q := range queries {
 l, r := q[0], q[1]+1
 length := sumNonZero[r] - sumNonZero[l]
-x := preNum[r] - preNum[l]*pow10[length]%mod // 注意结果可能是负数，所以下面 +mod
-ans[i] = (x + mod) * (sumD[r] - sumD[l]) % mod
+x := preNum[r] - preNum[l]*pow10[length]%mod + mod // +mod 保证结果非负
+ans[i] = x * (sumD[r] - sumD[l]) % mod
 }
 return ans
 }

leetcode/weekly/477/d/README.md

@@ -61,7 +61,7 @@ $$
 
 代码实现时，注意取模。为什么可以在中途取模？见 [模运算的世界：当加减乘除遇上取模](https://leetcode.cn/circle/discuss/mDfnkW/)。
 
-下午两点 [B站@灵茶山艾府](https://space.bilibili.com/206214) 直播讲题，欢迎关注~
+[本题视频讲解](https://www.bilibili.com/video/BV1arUKBbEks/)，欢迎点赞关注~
 
 ```py [sol-Python3]
 MOD = 1_000_000_007
@@ -78,18 +78,19 @@ class Solution:
  for x in nums:
  or_all |= x
 
- # 优化：如果 nums 只有一种数字，
- # 那么当这个数大于 0 时，可以把整个数组去掉，得到 OR=0，否则无法去掉任何子序列
+ # 优化：如果 nums 只有一种数字，可以把整个数组去掉，按位或 = 0 < or_all
  if len(set(nums)) == 1:
- return 1 if or_all else 0
+ return 1
 
- mx = or_all.bit_length()
- u = 1 << mx
+ w = or_all.bit_length()
+ u = 1 << w
  f = [0] * u
  for x in nums:
  f[x] += 1
- for i in range(mx):
+ for i in range(w):
  bit = 1 << i # 避免在循环中反复计算 1 << i
+ if or_all & bit == 0: # 优化：or_all 中是 0 的比特位无需计算
+ continue
  s = 0
  while s < u:
  s |= bit # 快速跳到第 i 位是 1 的 s
@@ -138,13 +139,16 @@ class Solution {
  or |= x;
  }
 
- int mx = 32 - Integer.numberOfLeadingZeros(or);
- int[] f = new int[1 << mx];
+ int w = 32 - Integer.numberOfLeadingZeros(or);
+ int[] f = new int[1 << w];
  for (int x : nums) {
  f[x]++;
  }
- for (int i = 0; i < mx; i++) {
- for (int s = 0; s < (1 << mx); s++) {
+ for (int i = 0; i < w; i++) {
+ if ((or >> i & 1) == 0) { // 优化：or 中是 0 的比特位无需计算
+ continue;
+ }
+ for (int s = 0; s < (1 << w); s++) {
  s |= 1 << i;
  f[s] += f[s ^ (1 << i)];
  }
@@ -181,18 +185,18 @@ int init = [] {
 class Solution {
 public:
  int countEffective(vector<int>& nums) {
- int or_ = 0;
- for (int x : nums) {
- or_ |= x;
- }
+ int or_ = reduce(nums.begin(), nums.end(), 0, bit_or<>());
+ int w = bit_width((uint32_t) or_);
 
-  int mx = bit_width((uint32_t) or_);
-  vector<int> f(1 << mx);
+  vector<int> f(1 << w);
   for (int x : nums) {
   f[x]++;
   }
- for (int i = 0; i < mx; i++) {
-  for (int s = 0; s < (1 << mx); s++) {
+ for (int i = 0; i < w; i++) {
+  if ((or_ >> i & 1) == 0) { // 优化：or_ 中是 0 的比特位无需计算
+  continue;
+  }
+  for (int s = 0; s < (1 << w); s++) {
   s |= 1 << i;
   f[s] += f[s ^ (1 << i)];
   }
@@ -231,13 +235,16 @@ func countEffective(nums []int) int {
 or |= x
 }
 
-mx := bits.Len(uint(or))
-f := make([]int, 1<<mx)
+w := bits.Len(uint(or))
+f := make([]int, 1<<w)
 for _, x := range nums {
 f[x]++
 }
-for i := range mx {
-for s := 0; s < 1<<mx; s++ {
+for i := range w {
+if or>>i&1 == 0 { // 优化：or 中是 0 的比特位无需计算
+continue
+}
+for s := 0; s < 1<<w; s++ {
 s |= 1 << i
 f[s] += f[s^1<<i]
 }

leetcode/weekly/477/d/d.go

@@ -21,13 +21,16 @@ func countEffective(nums []int) int {
 or |= x
 }
 
-mx := bits.Len(uint(or))
-f := make([]int, 1<<mx)
+w := bits.Len(uint(or))
+f := make([]int, 1<<w)
 for _, x := range nums {
 f[x]++
 }
-for i := range mx {
-for s := 0; s < 1<<mx; s++ {
+for i := range w {
+if or>>i&1 == 0 { // 优化：or 中是 0 的比特位无需计算
+continue
+}
+for s := 0; s < 1<<w; s++ {
 s |= 1 << i
 f[s] += f[s^1<<i]
 }