feat: 20260225 check in

Author: NoyeArk

leetcode/3-动态规划（基础版）/3-动态规划在字符串的应用/115. 不同的子序列.md

@@ -17,7 +17,7 @@
 
 3. 边界条件：
    - 如果$j < 0$，说明t已经匹配完成，返回1
-   - 如果$i < 0$或$i < j$，说明s已经用完但t还没匹配完，返回0
+   - 如果$i < 0$，说明s已经用完但t还没匹配完，返回0
 
 - 时间复杂度：$O(nm)$，其中 $n$ 和 $m$ 分别是 $s$ 和 $t$ 的长度
 - 空间复杂度：$O(nm)$，主要是记忆化数组的开销
@@ -31,7 +31,7 @@ class Solution:
         def dfs(i, j):
             if j < 0:
                 return 1
-            if i < 0 or i < j:
+            if i < 0:
                 return 0
             if s[i] != t[j]:
                 return dfs(i - 1, j)
@@ -96,15 +96,14 @@ public:
 class Solution:
     def numDistinct(self, s: str, t: str) -> int:
         n, m = len(s), len(t)
-        f = [[0] * (m + 1) for _ in range(n + 1)]
-        for i in range(n + 1):
-            f[i][0] = 1
-
-        for i in range(n):
-            for j in range(m):
-                f[i + 1][j + 1] = f[i][j + 1]
-                if s[i] == t[j]:
-                    f[i + 1][j + 1] += f[i][j]
+        f = [[1] + [0] * m for _ in range(n + 1)]
+
+        for i, c1 in enumerate(s):
+            for j, c2 in enumerate(t):
+                if c1 != c2:
+                    f[i + 1][j + 1] = f[i][j + 1]
+                else:
+                    f[i + 1][j + 1] = f[i][j + 1] + f[i][j]
         return f[n][m]
 ```
 
@@ -117,6 +116,4 @@ class Solution:
 1. $f[i][j]$ 表示区间 $[i, j]$ 内字符串 t 出现的次数，但是这种表示太不方便计算了，感觉不对
 2. 想不出来 $f[i][j]$ 还有什么状态表示了
 
-然后看了题解，发现这道题的难点在于状态表示，如果状态表示对了，那么这道题就很简单了。
-
-这道题的难点在于状态表示，如果状态表示对了，那么这道题就很简单了。
+然后看了题解，发现这道题的难点在于状态表示，如果状态表示对了，那么这道题就很简单了。

leetcode/4-每日一题/1356. 根据数字二进制下 1 的数目排序.md

@@ -0,0 +1,48 @@
+# [1356. 根据数字二进制下 1 的数目排序](https://leetcode.cn/problems/sort-integers-by-the-number-of-1-bits/description/)
+
+> **日期**：2026-02-25  
+> **所用时间**：1min  
+> **知识点**：排序、位运算
+
+## 1. 题目描述
+
+给你一个整数数组 `arr`。请你将数组中的元素按照其二进制表示中数字 **1** 的数目升序排序。
+
+若存在多个数字二进制中 **1** 的数目相同，则必须将它们按照数值大小升序排列。
+
+请你返回排序后的数组。
+
+**示例 1：**
+
+- **输入**：arr = [0,1,2,3,4,5,6,7,8]
+- **输出**：[0,1,2,4,8,3,5,6,7]
+- **解释**：二进制中 1 的个数分别为 0,1,1,2,1,2,2,3,1，按个数排序后再按数值排序得到 [0,1,2,4,8,3,5,6,7]。
+
+**示例 2：**
+
+- **输入**：arr = [1024,512,256,128,64,32,16,8,4,2,1]
+- **输出**：[1,2,4,8,16,32,64,128,256,512,1024]
+
+**提示：**
+
+- `1 <= arr.length <= 500`
+- `0 <= arr[i] <= 10^4`
+
+## 2. 排序
+
+自定义排序：以「二进制中 1 的个数」为第一关键字升序，「数值」为第二关键字升序。Python 中可用 `sorted(arr, key=lambda x: (x.bit_count(), x))`，其中 `bit_count()` 为 Python 3.10+ 内置方法；
+
+若环境不支持 `bit_count()` 方法，可用 `bin(x).count('1')` 替代。
+
+复杂度分析：
+
+- 时间复杂度：$O(n\log n)$，其中 $n$ 为数组长度，排序主导。
+- 空间复杂度：$O(\log n)$，排序栈空间（若不计返回数组）。
+
+**Python3**
+
+```python
+class Solution:
+    def sortByBits(self, arr: List[int]) -> List[int]:
+        return sorted(arr, key=lambda x: (x.bit_count(), x))
+```

leetcode/4-每日一题/3714. 最长的平衡子串 II.md

@@ -0,0 +1,104 @@
+# [3714. 最长的平衡子串 II](https://leetcode.cn/problems/longest-balanced-substring-ii/description/)
+
+> **日期**：2026-02-19  
+> **知识点**：前缀和、哈希表
+
+## 1. 题目描述
+
+给定一个字符串 `s`，请找出其中最长的**平衡子串**的长度。
+
+**平衡子串**的定义：子串中所有出现过的字符，出现次数都相同。
+
+例如：
+- `"ab"`、`"aabb"`、`"abc"`、`"aabbcc"` 都是平衡的（每种字符出现次数相等）；
+- `"aab"` 不是平衡的（a 出现 2 次，b 出现 1 次）。
+
+**约束：**
+- `1 <= s.length <= 10^5`（或题目给定）
+- `s` 仅由小写英文字母组成（最多 26 种字符，本题可只考虑 a/b/c 三类）
+
+**示例 1：**
+
+```
+输入：s = "abc"
+输出：3
+解释：整个串 "abc" 中 a、b、c 各出现 1 次，是平衡的，长度为 3。
+```
+
+**示例 2：**
+
+```
+输入：s = "aabb"
+输出：4
+解释："aabb" 中 a 和 b 各出现 2 次，是平衡的，长度为 4。
+```
+
+**示例 3：**
+
+```
+输入：s = "aaa"
+输出：1
+解释：仅一种字符时，可视为出现次数相同，最长平衡子串长度为 1。
+```
+
+## 2. 分类讨论（单字符 / 两字符 / 三字符）+ 前缀和与哈希表
+
+平衡子串只可能由**一种、两种或三种**字符组成，分三类处理：
+
+- **情况一（单字符）**：最长连续相同字符段，扫一遍用 `last` 维护当前段长，更新最大值。
+- **情况二（两种字符 x, y）**：只含 x、y 的极长段内，将 x 视为 +1、y 视为 -1 做前缀差 `diff`；相同 `diff` 的两位置之间即平衡子串。用哈希表记录每个 `diff` 首次出现位置，枚举右端点更新答案。对 (a,b)、(b,c)、(a,c) 各跑一遍取最大。
+- **情况三（三种字符 a,b,c）**：用 `pre[0],pre[1],pre[2]` 表示 a,b,c 的前缀个数，平衡等价于 `pre[i]-pre[j]` 在两维上都相等。以 `(pre[0]-pre[1], pre[1]-pre[2])` 为 key 存首次下标，枚举右端点更新答案。
+
+复杂度分析：
+
+- **时间复杂度**：$O(n)$，单字符与三字符各一遍扫描，两字符对三组 (x,y) 各 $O(n)$。
+- **空间复杂度**：$O(n)$ 或 $O(1)$（哈希表 key 数量有界）。
+
+**Python3**
+
+```python
+class Solution:
+    def longestBalanced(self, s: str) -> int:
+        n = len(s)
+        ans = 0
+
+        # 情况一
+        last = 0
+        for i in range(n):
+            last = last + 1 if i > 0 and s[i] == s[i - 1] else 1
+            ans = max(ans, last)
+        
+        # 情况二
+        def work(x, y):
+            ans = 0
+            i = 0
+            while i < n:
+                if s[i] not in (x, y):
+                    i += 1
+                    continue
+                pos = {0: i - 1}
+                diff = 0
+                while i < n and s[i] in (x, y):
+                    diff += 1 if s[i] == x else -1
+                    if diff in pos:
+                        ans = max(ans, i - pos[diff])
+                    else:
+                        pos[diff] = i
+                    i += 1
+                i += 1
+            return ans
+        
+        ans = max(ans, work('a', 'b'), work('b', 'c'), work('a', 'c'))
+
+        # 情况三
+        pre = [0, 0, 0]
+        pos = {(0, 0): -1}
+        for i, c in enumerate(s):
+            pre[ord(c) - 97] += 1
+            key = (pre[0] - pre[1], pre[1] - pre[2])
+            if key in pos:
+                ans = max(ans, i - pos[key])
+            else:
+                pos[key] = i
+        return ans
+```

leetcode/5-周赛/第 415 场周赛/3290. 最高乘法得分.md

@@ -1,23 +1,49 @@
-# [3290. 最高乘法得分](https://leetcode.cn/problems/maximum-multiplication-score/description/)
+# 3290. 最高乘法得分
 
-> **日期:** 2024-09-15
-> **所用时间:** 12min
+> **日期**：2024-09-15  
+> **所用时间**：12min  
+> **知识点**：动态规划、记忆化搜索
 
-## 1. 记忆化搜索
+## 1. 题目描述
 
-状态表示：$dfs(i, j)$ 表示在区间 $[0, i]$ 内选择 $j$ 个数
+给定两个整数数组 `a` 和 `b`，长度分别为 `n` 和 `m`（保证 $m \ge n$）。
 
-状态计算：对于第$i$个数来说，有两种做法：选和不选
-
-1. 选第$i$个数，则$dfs(i - 1, j - 1) + a[i] \times b[j - 1]$
-2. 不选，则$dfs(i - 1, j)$
-
-最终的状态计算方程如下：
+你需要从 `b` 中**按顺序**选出恰好 `n` 个下标 $j_0 < j_1 < \cdots < j_{n-1}$，并将 `a[i]` 与 `b[j_i]` 一一配对。**乘法得分**定义为所有配对乘积之和：
 
 $$
-    \max(dfs(i - 1, j), dfs(i - 1, j - 1) + a[i] \times b[j - 1])
+\sum_{i=0}^{n-1} a[i] \times b[j_i]
 $$
 
+求可能得到的**最高乘法得分**。
+
+**示例 1：**
+
+- **输入**：a = [2, 1, 3], b = [1, 2, 3, 4]
+- **输出**：20
+- **解释**：从 b 中按顺序选 3 个下标与 a 配对，使乘积和最大即可得到 20。
+
+**示例 2：**
+
+- **输入**：a = [1, 2], b = [1, 2, 3]
+- **输出**：8
+- **解释**：选 b 的下标 [1, 2]，得分为 1*2 + 2*3 = 8。
+
+**提示：**
+
+- $1 \le n \le m$
+- $1 \le n, m \le 500$
+- 数组元素为整数（可能为负，以题目约束为准）。
+
+## 2 记忆化搜索
+
+状态：$dfs(i, j)$ 表示在数组 `a` 的前 $i+1$ 个元素与数组 `b` 的前 $j+1$ 个元素中，已按顺序配对完 $a[0..i]$ 与某 $j+1$ 个位置中的 $i+1$ 个来自 `b` 的元素时，能得到的最大得分（即从 `b[0..j]` 里选恰好 $i+1$ 个做配对）。
+
+- **当 $i < 0$**：无元素可配，返回 $0$。
+- **当 $i = j$**：`a[0..i]` 与 `b[0..j]` 长度均为 $i+1$，必须一一配对，故 $dfs(i, j) = dfs(i-1, j-1) + a[i] \times b[j]$。
+- **当 $i \neq j$**：要么将 $a[i]$ 与 $b[j]$ 配对，得 $dfs(i-1, j-1) + a[i] \times b[j]$；要么不选 $b[j]$，得 $dfs(i, j-1)$。取两者最大值。
+
+复杂度分析：
+
 - 时间复杂度：$O(nm)$
 - 空间复杂度：$O(nm)$
 
@@ -28,42 +54,24 @@ class Solution:
     def maxScore(self, a: List[int], b: List[int]) -> int:
         @cache
         def dfs(i, j):
-            if j == 0:
-                return 0
             if i < 0:
-                return -inf
-            return max(dfs(i - 1, j), dfs(i - 1, j - 1) + a[j - 1] * b[i])
-        return dfs(len(b) - 1, 4)
+                return 0
+            if i == j:
+                return dfs(i - 1, j - 1) + a[i] * b[j]
+            return max(dfs(i - 1, j - 1) + a[i] * b[j], dfs(i, j - 1))
+        return dfs(len(a) - 1, len(b) - 1)
 ```
 
-## 2. 第二种记忆化搜索的状态定义
-
-### 状态表示
-
-$dfs(i, j, k)$ 表示在数组 $a$ 的前 $i$ 个元素和数组 $b$ 的前 $j$ 个元素中选择 $k$ 个数
-
-### 状态计算
-
-对于第 $i$ 个元素和第 $j$ 个元素来说，有两种情况：
+## 3 递推（DP 表）
 
-1. 如果 $i = j$，则必须同时选择这两个元素，状态转移为 $dfs(i - 1, j - 1, k - 1) + a[i] \times b[j]$
-2. 如果 $i \neq j$，则有两种选择：
-   - 不选择数组 $b$ 的第 $j$ 个元素，状态转移为 $dfs(i, j - 1, k)$
-   - 同时选择数组 $a$ 的第 $i$ 个元素和数组 $b$ 的第 $j$ 个元素，状态转移为 $dfs(i - 1, j - 1, k - 1) + a[i] \times b[j]$
+将上述记忆化搜索改为递推：$f[i][j]$ 表示考虑 `a` 的前 $i$ 个元素与 `b` 的前 $j$ 个元素时能得到的最大得分（即从 `b[0..j-1]` 中选恰好 $i$ 个与 `a[0..i-1]` 配对的最大和）。
 
-### 边界条件
+- 当 $i = j$：必须配对 $a[i-1]$ 与 $b[j-1]$，故 $f[i][j] = f[i-1][j-1] + a[i-1] \times b[j-1]$。
+- 当 $i \neq j$：要么配对 $a[i-1]$ 与 $b[j-1]$，得 $f[i-1][j-1] + a[i-1] \times b[j-1]$；要么不选 $b[j-1]$，得 $f[i][j-1]$。取最大值。
 
-- 当 $k = 0$ 时，说明已经选择了 $k$ 个数，返回 0
-- 当 $i < 0$ 或 $j < 0$ 时，说明数组 $a$ 或 $b$ 已经遍历完了，返回 0
+按 $i$、$j$ 递增递推，答案为 $f[n][m]$。
 
-### 状态计算方程
-
-$$
-\begin{cases}
-dfs(i - 1, j - 1, k - 1) + a[i] \times b[j], & \text{if } i = j \\
-\max(dfs(i, j - 1, k), dfs(i - 1, j - 1, k - 1) + a[i] \times b[j]), & \text{if } i \neq j
-\end{cases}
-$$
+复杂度分析：
 
 - 时间复杂度：$O(nm)$
 - 空间复杂度：$O(nm)$
@@ -73,12 +81,14 @@ $$
 ```python
 class Solution:
     def maxScore(self, a: List[int], b: List[int]) -> int:
-        @cache
-        def dfs(i, j, k):
-            if k == 0 or i < 0 or j < 0:
-                return 0
-            if i == j:
-                return dfs(i - 1, j - 1, k - 1) + a[i] * b[j]
-            return max(dfs(i, j - 1, k), dfs(i - 1, j - 1, k - 1) + a[i] * b[j])
-        return dfs(len(a) - 1, len(b) - 1, 4)
+        n, m = len(a), len(b)
+        f = [[0] * (m + 1) for _ in range(n + 1)]
+
+        for i, x in enumerate(a):
+            for j, y in enumerate(b):
+                if i == j:
+                    f[i + 1][j + 1] = f[i][j] + x * y
+                else:
+                    f[i + 1][j + 1] = max(f[i][j] + x * y, f[i + 1][j])
+        return f[n][m]
 ```