feat: 20260204 check in

Author: NoyeArk

leetcode/4-每日一题/3640. 三段式数组 II.md

@@ -0,0 +1,68 @@
+# [3640. 三段式数组 II](https://leetcode.cn/problems/three-part-array-ii/description/)
+
+> **日期**：2026-02-04  
+> **所用时间**：8min  
+> **知识点**：动态规划
+
+## 1. 题目描述
+
+给你一个长度为 n 的整数数组 `nums`。
+
+若数组能被划分为三段，且满足以下性质，则称为**三段式数组（trionic）**：
+
+- **第一段**：严格递增（从左到右）
+- **第二段**：严格递减
+- **第三段**：严格递增
+
+其中相邻元素不能相等（严格单调）。三段必须非空，且顺序为「增 → 减 → 增」。
+
+请返回所有可能的三段式子数组的**最大和**。如果不存在三段式子数组，返回一个足够小的值（如 `-inf`）。
+
+**示例：**
+
+- `nums = [1, 3, 2, 4]`：存在三段式子数组 `[1, 3, 2, 4]`，和为 10
+- `nums = [1, 2, 3]`：不存在三段式子数组，返回 `-inf`
+
+**约束：** 3 ≤ nums.length ≤ 10⁵
+
+## 2. 解题算法
+
+本题是**动态规划**问题，需要找到所有可能的三段式子数组并求最大和。
+
+**状态定义：**
+- `f1`：当前处于第一段（递增段）的最大和
+- `f2`：当前处于第二段（递减段）的最大和  
+- `f3`：当前处于第三段（递增段）的最大和
+
+**状态转移：**
+遍历相邻元素对 `(x, y)`：
+
+1. **第一段（f1）**：`x < y` 时，可以继续第一段或开始第一段
+   - `f1 = max(f1, 0) + y`（取之前最大值或从当前位置开始）
+
+2. **第二段（f2）**：`x > y` 时，必须从第一段转移而来
+   - `f2 = max(f2, f1) + y`（从第一段的最大值转移）
+
+3. **第三段（f3）**：`x < y` 时，必须从第二段转移而来
+   - `f3 = max(f3, f2) + y`（从第二段的最大值转移）
+
+**初始化：** 所有状态初始化为 `-inf`，表示尚未达到该阶段。
+
+**复杂度分析：**
+
+- 时间复杂度：O(n)，单次遍历数组
+- 空间复杂度：O(1)，仅用三个状态变量
+
+**Python3**
+
+```python
+class Solution:
+    def maxSumTrionic(self, nums: List[int]) -> int:
+        ans = f1 = f2 = f3 = -inf
+        for x, y in pairwise(nums):
+            f3 = max(f3, f2) + y if x < y else -inf
+            f2 = max(f2, f1) + y if x > y else -inf
+            f1 = max(f1, x) + y if x < y else -inf
+            ans = max(ans, f3)
+        return ans
+```

leetcode/其他/3489. 零数组变换 IV.md

@@ -0,0 +1,68 @@
+# [3489. 零数组变换 IV](https://leetcode.cn/problems/zero-array-transformation-iv/description/)
+
+> **日期**：2025-06-10  
+> **所用时间**：10min  
+> **知识点**：动态规划、子集和、0-1 背包
+
+## 1. 题目描述
+
+给定一个整数数组 `nums` 和一个二维数组 `queries`，其中每个查询 `[l, r, val]` 表示可以选择区间 `[l, r]` 内的任意子集下标，将这些下标对应的值减去 `val`。求将所有元素变为 0 所需的最少查询次数 `k`，若不可能则返回 -1。
+
+**示例 1：**
+
+```
+输入：nums = [3, 2, 1], queries = [[0, 2, 1], [0, 1, 2]]
+输出：2
+解释：
+- 第 1 次操作选择 [0,1,2] 下标的全部，使得 nums = [2, 1, 0]
+- 第 2 次操作选择 [0,1]，再各减 2（只影响下标 0），nums = [0, 1, 0]
+- 由于 nums[1]=1 还需要操作一次，但无合适区间，所以最少共用 2 次
+```
+
+**示例 2：**
+
+```
+输入：nums = [1, 2, 3], queries = [[0, 2, 2]]
+输出：-1
+解释：
+- 唯一一次操作不能把所有元素变成 0。
+```
+
+## 2. 解题算法
+
+思路：每个下标可以独立选择是否应用覆盖它的每个查询，因此问题转化为：对于每个元素，其值能否表示为覆盖它的查询值的子集和。
+
+1. 对每个下标 `i`，若 `nums[i] = 0` 则跳过
+2. 收集所有覆盖下标 `i` 的查询（即 `l <= i <= r`）
+3. 使用 0-1 背包思想：`f[j]` 表示能否用已考虑的查询值凑出和 `j`
+4. 按查询顺序遍历，对每个覆盖 `i` 的查询更新 DP：`f[j] |= f[j - val]`
+5. 当 `f[nums[i]]]` 为真时，记录所需查询数 `k + 1`，取所有下标的最大值
+6. 若任一元素无法变为 0，返回 -1
+
+复杂度分析：
+- 时间复杂度：$O(n \times q \times V)$，其中 $n$ 为数组长度，$q$ 为查询数，$V$ 为元素值上界（最大约 1000）
+- 空间复杂度：$O(V)$
+
+**Python3**
+
+```python
+class Solution:
+    def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:
+        ans = 0
+        for i, x in enumerate(nums):
+            if x == 0:
+                continue
+            
+            f = [True] + [False] * x
+            for k, (l, r, val) in enumerate(queries):
+                if i < l or i > r:
+                    continue
+                for j in range(x, val - 1, -1):
+                    f[j] |= f[j - val]
+                if f[x]:
+                    ans = max(ans, k + 1)
+                    break
+            else:
+                return -1
+        return ans
+```