feat: 第490场周赛

Author: NoyeArk

leetcode/5-周赛/Readme.md

@@ -1,5 +1,19 @@
 # 力扣周赛记录
 
+## 第 490 场周赛
+
+**时间**：2026-02-22
+
+**竞赛分数**：📈1653 / 692
+
+**总结**：这次周赛整体难度不大，全部做出来了，继续加油。
+
+|序号|   题目名称     | 通过数据点 | 知识点 |
+|---| -------------- | --- | --- |
+| 1 | [3847. 计算比赛分数差](/leetcode/5-周赛/第%20490%20场周赛/3847.%20计算比赛分数差.md) | 100% | 模拟 |
+| 2 | [3848. 阶数数字排列](/leetcode/5-周赛/第%20490%20场周赛/3848.%20阶数数字排列.md) | 100% | 数学 |
+| 3 | [3849. 重新排列后的最大按位异或值](/leetcode/5-周赛/第%20490%20场周赛/3849.%20重新排列后的最大按位异或值.md) | 100% | 贪心 |
+| 4 | [3850. 统计结果等于 K 的序列数目](/leetcode/5-周赛/第%20490%20场周赛/3850.%20统计结果等于%20K%20的序列数目.md) | 100% | 记忆化搜索 |
 
 ## 第 428 场周赛
 

leetcode/5-周赛/第 490 场周赛/3847. 计算比赛分数差.md

@@ -0,0 +1,56 @@
+# [3847. 计算比赛分数差](https://leetcode.cn/problems/find-the-score-difference-in-a-game/)
+
+> **日期**：2026-02-23  
+> **所用时间**：10min  
+> **知识点**：模拟
+
+## 1. 题目描述
+
+给定一个整数数组 `nums`，按顺序模拟一场两人比赛的计分过程，计算最终两人分数之差。
+
+**规则：**
+
+- 初始两个分数 `s1`、`s2` 均为 0，当前加分的「对象」为 `s1`。
+- 从左到右遍历 `nums`，对于下标为 `i`、数值为 `x` 的元素：
+  - 若 `x` 为**奇数**，则先交换「当前加分对象」与另一人（即 `s1` 与 `s2` 互换角色），再给当前对象加上 `x`。
+  - 若 `(i + 1) % 6 == 0`（即第 6、12、18… 个元素），同样先交换一次加分对象，再给当前对象加上 `x`。
+  - 其余情况直接给当前对象加上 `x`。
+- 返回最终**先手方分数减后手方分数**的差值（根据过程中交换次数的奇偶性确定谁算「先手」）。
+
+**示例：**
+
+（可根据题意补充具体输入输出；若题目为「先手减后手」则差值为 `s1 - s2` 或 `s2 - s1` 依交换次数奇偶而定。）
+
+**提示：**
+
+- `1 <= nums.length <= 10^5`
+- `1 <= nums[i] <= 10^5`
+
+## 2. 模拟 + 双变量交替
+
+用 `s1`、`s2` 表示当前两人的分数，用 `change` 记录「交换次数」。遍历时：遇奇数或 `(i+1)%6==0` 则交换 `s1` 与 `s2` 并令 `change += 1`；每次将当前数加到 `s1`。
+
+最后若 `change` 为偶数则先手对应 `s1`，否则先手对应 `s2`，返回先手分数减后手分数的差值。
+
+复杂度分析：
+
+- 时间复杂度：$O(n)$。
+- 空间复杂度：$O(1)$。
+
+**Python3**
+
+```python
+class Solution:
+    def scoreDifference(self, nums: List[int]) -> int:
+        s1 = s2 = 0
+        change = 0
+        for i, x in enumerate(nums):
+            if x % 2 == 1:
+                s1, s2 = s2, s1
+                change += 1
+            if (i + 1) % 6 == 0:
+                s1, s2 = s2, s1
+                change += 1
+            s1 += x
+        return s1 - s2 if change % 2 == 0 else s2 - s1
+```

leetcode/5-周赛/第 490 场周赛/3848. 阶数数字排列.md

@@ -0,0 +1,55 @@
+# [3848. 阶数数字排列](https://leetcode.cn/problems/check-digitorial-permutation/)
+
+> **日期**：2026-02-22  
+> **所用时间**：10min  
+> **知识点**：数学
+
+## 1. 题目描述
+
+给定一个正整数 `n`，定义其**阶数和**为：将 `n` 的每一位数字的阶乘相加得到的数。例如 `n = 145` 时，阶数和为 `1! + 4! + 5! = 1 + 24 + 120 = 145`。
+
+判断：`n` 的阶数和 `s` 与 `n` 是否由**相同的一组数字**组成（即 `s` 的各位数字重排后能否得到 `n`，或等价地，`sorted(str(s)) == sorted(str(n))`）。
+
+**示例 1：**
+
+```
+输入：n = 145
+输出：true
+解释：1!+4!+5! = 145，145 与 145 数字相同。
+```
+
+**示例 2：**
+
+```
+输入：n = 12
+输出：false
+解释：1!+2! = 3，数字 "3" 与 "12" 不同。
+```
+
+**提示：**
+
+- `1 <= n <= 10^9`（或题目给定范围）
+
+## 2. 阶乘求和 + 数字集合比较
+
+先定义阶乘 `f(x) = x!`（`f(0)=1`），用记忆化避免重复计算。将 `n` 的每一位数字的阶乘相加得到 `s`，再比较 `s` 与 `n` 的**数字多重集**是否相同：即 `sorted(str(s)) == sorted(str(n))`。
+
+复杂度分析：
+
+- 时间复杂度：$O(\log n)$（位数），阶乘计算为常数次（0~9）。
+- 空间复杂度：$O(1)$（阶乘缓存与数字串）。
+
+**Python3**
+
+```python
+class Solution:
+    def isDigitorialPermutation(self, n: int) -> bool:
+        @cache
+        def f(x):
+            if x == 0:
+                return 1
+            return x * f(x - 1)
+
+        s = sum(f(int(c)) for c in str(n))
+        return sorted(str(s)) == sorted(str(n))
+```

leetcode/5-周赛/第 490 场周赛/3849. 重新排列后的最大按位异或值.md

@@ -0,0 +1,56 @@
+# [3849. 重新排列后的最大按位异或值](https://leetcode.cn/problems/maximum-bitwise-xor-after-rearrangement/)
+
+> **日期**：2026-02-22  
+> **所用时间**：25min  
+> **知识点**：贪心、计数
+
+## 1. 题目描述
+
+给定两个**二进制字符串** `s` 和 `t`，长度相同。你可以**任意重排** `t` 中的字符。将重排后的 `t` 与 `s` **按位异或**（即第 i 位为 `s[i] ^ t[i]`），得到一个二进制串。求在所有重排方案中，该异或结果**数值最大**时对应的二进制串（通常也等价于字典序最大）。
+
+**示例 1：**
+
+```
+输入：s = "010", t = "110"
+输出："101"
+解释：将 t 重排为 "101"，与 s 按位异或得 010^101 = 111；或重排为 "011" 得 001，最大为 "111"。若输出为 "101" 则可能表示某种题意下的最大异或串。
+```
+
+**示例 2：**
+
+```
+输入：s = "0", t = "0"
+输出："0"
+解释：无法得到 1，结果为 "0"。
+```
+
+**提示：**
+
+- `1 <= s.length, t.length <= 10^5`
+- `s`、`t` 仅由 `'0'` 和 `'1'` 组成
+
+## 2. 贪心 + 计数
+
+要使异或结果最大，应尽量在**高位**得到 `1`。从左到右遍历 `s` 的每一位：当前位若为 `c`，则异或为 1 当且仅当该位与 `1-c`（相反位）配对。
+
+用计数器维护 `t` 中剩余可用的 `'0'` 与 `'1'` 个数；每步优先使用与当前位相反的字符（若还有），则当前位异或为 1，否则为 0。这样得到的就是字典序（数值）最大的异或串。
+
+- **时间复杂度**：$O(n)$，n 为串长。
+- **空间复杂度**：$O(1)$（仅计数）。
+
+**Python3**
+
+```python
+class Solution:
+    def maximumXor(self, s: str, t: str) -> str:
+        cnt = Counter(t)
+        if cnt['1'] == 0:
+            return s
+
+        ans = ''
+        for c in s:
+            reverse = str(1-int(c))
+            ans += '1' if cnt[reverse] > 0 else '0'
+            cnt[reverse] -= 1
+        return ans
+```

leetcode/5-周赛/第 490 场周赛/3850. 统计结果等于 K 的序列数目.md

@@ -0,0 +1,50 @@
+# [3850. 统计结果等于 K 的序列数目](https://leetcode.cn/problems/count-sequences-to-k/)
+
+> **日期**：2026-02-22  
+> **所用时间**：30min  
+> **知识点**：记忆化搜索、DFS
+
+## 1. 题目描述
+
+给定一个整数数组 `nums` 和一个整数 `k`。对每个下标 `i`，你可以从三种操作中任选其一：**不选**该数、将当前结果**乘以** `nums[i]`、或将当前结果**除以** `nums[i]`（整除或浮点除依题意）。每个位置至多使用一次。
+
+求有多少种**操作序列**，使得按顺序执行后得到的**结果等于** `k`。
+
+（若题意为「从右到左」或「表达式结果为 k」等变种，逻辑等价：用当前值 `k` 倒推，DFS 时枚举不选 / 乘 / 除三种后继状态，边界为下标越界时检查当前值是否为 1 或 k。）
+
+**示例 1：**
+
+```
+输入：nums = [2, 3, 4], k = 6
+输出：（依题意计算）
+解释：例如 2 * 3 = 6、或 4 不选且 2*3=6 等，统计所有使结果等于 k 的序列数。
+```
+
+**提示：**
+
+- `1 <= nums.length <= 30`
+- `1 <= nums[i], k <= 10^9`（或题目给定范围）
+
+## 2. 记忆化 DFS
+
+从右到左（或从左到右）枚举下标 `i`，当前「目标值」为 `k`：若已处理完所有元素（`i < 0`），则若当前目标为 1 则贡献 1 种方案，否则 0；否则三种分支：不选 `nums[i]`（目标仍为 `k`）、选乘（目标变为 `k / nums[i]`）、选除（目标变为 `k * nums[i]`）。
+
+用 `@cache` 记忆化 `(i, k)` 的答案，避免重复计算。注意浮点比较时用 `abs(1 - k) < 1e-5` 等判等。
+
+复杂度分析：
+
+- 时间复杂度：$O(n \cdot S)$，其中 $S$ 为状态数（与 k 的因子或离散化后的状态数相关）。
+- 空间复杂度：$O(n \cdot S)$，为记忆化缓存。
+
+**Python3**
+
+```python
+class Solution:
+    def countSequences(self, nums: List[int], k: int) -> int:
+        @cache
+        def dfs(i, k):
+            if i < 0:
+                return int(abs(1 - k) < 1e-5)
+            return dfs(i - 1, k) + dfs(i - 1, k * nums[i]) + dfs(i - 1, k / nums[i])
+        return dfs(len(nums) - 1, k)
+```