feat: 20260312 check in

Author: NoyeArk

leetcode/4-每日一题/3600. 升级后最大生成树稳定性.md

@@ -0,0 +1,108 @@
+# 3600. 升级后最大生成树稳定性
+
+> **日期**：2026-03-12  
+> **所用时间**：45min  
+> **知识点**：并查集、二分答案
+
+## 1. 并查集 + 二分答案
+
+### 题意与目标
+
+- 无向图有 $n$ 个点、若干条边，每条边有**稳定性** $s$，且可能是**必选**或**可选**。
+- 可以花费 1 次机会将某条可选边的稳定性从 $s$ 升级为 $2s$，最多升级 $k$ 次。
+- 求：在形成一棵生成树的前提下，**生成树中边的最小稳定性**（即树的稳定性）最大能是多少；若无法形成生成树则返回 $-1$。
+
+### 思路概述
+
+答案具有单调性：若稳定性 $x$ 能达到，则比 $x$ 更小的稳定性也能达到。因此可以**二分答案**：二分「最终生成树的最小稳定性」$mid$，用 `check(mid)` 判断：能否在至多 $k$ 次升级内，选边形成一棵生成树，且每条边的稳定性都 $\ge mid$。
+
+二分范围：下界为所有边中最小的 $s$（`min_s`），上界为「某条边升级后的最大稳定性」$2 \cdot \max_s$，因此取 `[min_s, max_s * 2 + 1)` 即可（右开便于二分）。
+
+### check(mid) 的逻辑
+
+要判断「能否在至多 $k$ 次升级下，得到一棵稳定性均 $\ge mid$ 的生成树」，可以按边分类处理：
+
+1. **必选边**  
+   - 若某条必选边的 $s < mid$，说明即使用上这条边，稳定性也达不到 $mid$，直接返回 `False`。  
+   - 否则（$s \ge mid$）必须加入生成树，在并查集中合并两端点。
+
+2. **可选边**  
+   - $s \ge mid$：不升级也能用，直接加入并查集。  
+   - $s < mid \le 2s$：升级一次后稳定性变为 $2s \ge mid$，可以选用，但会消耗 1 次升级机会。  
+   - $mid > 2s$：升级后仍达不到 $mid$，不能选。
+
+实现时可以先**第一遍扫所有边**：必选边若 $s < mid$ 则返回 `False`；否则对「必选边」或「$s \ge mid$ 的边」执行合并。再**第二遍扫所有边**：只处理可选边且 $s < mid \le 2s$ 的，在升级次数 $t \le k$ 且能合并（不形成环）时合并并 `t -= 1`。最后看并查集是否只剩一个连通分量（`u.cnt == 1`），是则说明能形成一棵满足条件的生成树。
+
+### 主流程与预处理
+
+- **无解**：  
+  - 必选边成环（同一并查集里再合并必选边会失败）则无解。  
+  - 把所有边（必选+可选）都加入另一个并查集后，若图不连通（`all_uf.cnt > 1`）则无法形成生成树，也无解。  
+- **有解**：在 `[min_s, max_s * 2 + 1)` 上二分最大的 $mid$ 使得 `check(mid)` 为真，该 $mid$ 即为答案。
+
+### 复杂度分析
+
+- **时间复杂度**：预处理并查集与最值 $O(E \cdot \alpha(V))$；二分 $O(\log S)$ 次，每次 `check` 遍历边并查集合并 $O(E \cdot \alpha(V))$，合计 $O(E \cdot \alpha(V) \cdot \log S)$，$S$ 为稳定性上界（如 `max_s * 2`）。
+- **空间复杂度**：并查集 $O(V)$，以及若干变量 $O(1)$。
+
+**Python3**
+
+```python
+class UnionFind:
+    def __init__(self, n):
+        self.fa = list(range(n))
+        self.cnt = n
+    
+    def find(self, x):
+        if self.fa[x] != x:
+            self.fa[x] = self.find(self.fa[x])
+        return self.fa[x]
+    
+    def merge(self, a, b):
+        a, b = self.find(a), self.find(b)
+        if a == b:
+            return False
+        self.fa[a] = b
+        self.cnt -= 1
+        return True
+
+class Solution:
+    def maxStability(self, n: int, edges: List[List[int]], k: int) -> int:
+        all_uf = UnionFind(n)
+        must_uf = UnionFind(n)
+        min_s, max_s = inf, 0
+        for x, y, s, must in edges:
+            if must and not must_uf.merge(x, y):
+                return -1
+            all_uf.merge(x, y)
+            min_s = min(min_s, s)
+            max_s = max(max_s, s)
+        
+        if all_uf.cnt > 1:
+            return -1
+        
+        def check(mid):
+            u = UnionFind(n)
+            for x, y, s, must in edges:
+                if must and s < mid:
+                    return False
+                if must or s >= mid:
+                    u.merge(x, y)
+            
+            t = k
+            for x, y, s, must in edges:
+                if t == 0 or u.cnt == 1:
+                    break
+                if not must and s < mid <= s * 2 and u.merge(x, y):
+                    t -= 1
+            return u.cnt == 1
+        
+        l, r = min_s, max_s * 2 + 1
+        while l < r:
+            mid = l + r + 1 >> 1
+            if check(mid):
+                l = mid
+            else:
+                r = mid - 1
+        return r
+```

leetcode/5-周赛/第 492 场周赛/3863. 将一个字符串排序的最小操作次数.md

@@ -0,0 +1,35 @@
+# 3863. 将一个字符串排序的最小操作次数
+
+> **日期**：2026-03-12  
+> **所用时间**：3min  
+> **知识点**：分类讨论
+
+## 1. 贪心 + 分类讨论
+
+若串已有序（任意相邻字符非严格递增）则答案为 0。若长度为 2 且无序，则无法在有限次操作内排好序，返回 -1。否则记全局最小字符为 `mi`、最大为 `mx`：若最小字符已在首位或最大字符已在末位，说明一次操作即可（把最小移到最前或把最大移到最后）；若 `mi` 或 `mx` 出现在中间某个位置，则两次操作可完成；否则需要三次操作。
+
+复杂度分析：
+
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(1)$
+
+**Python3**
+
+```python
+class Solution:
+    def minOperations(self, s: str) -> int:
+        if all(x <= y for x, y in pairwise(s)):
+            return 0
+        
+        if len(s) == 2:
+            return -1
+        
+        mi, mx = min(s), max(s)
+        if s[0] == mi or s[-1] == mx:
+            return 1
+        
+        if any(c in (mi, mx) for c in s[1:-1]):
+            return 2
+        
+        return 3
+```