Jeanphilo Blog

分层之后，为什么每一层还在重复校验？

Sun, 25 Oct 2026 00:00:00 +0000

用一个修改商品价格的例子，区分入口类型检查、领域业务约束与存储转换，减少分层系统中的重复校验和无目的抽象。

让 Agent 少写防御性代码：每条校验都要有理由

Sun, 25 Oct 2026 00:00:00 +0000

从策略工具的数组转换、反馈读取和查询筛选三个例子出发，判断哪些校验有实际用途，哪些只是重复工作，并给出约束 Agent 的编码规则。

Pydantic 的 field_validator：字段什么时候校验，返回值去了哪里？

Thu, 22 Oct 2026 17:00:00 +0800

用考试成绩校验理解 Pydantic v2 的 field_validator：自动调用、返回值、ValueError 和校验顺序。

Skill、MCP 与 CLI：工具编排复杂了，就该上 MCP 吗？

Thu, 22 Oct 2026 00:00:00 +0000

Skill 与 MCP 解决不同层次的复用问题，CLI 也没有因此过时。本文用代码审查场景解释三者的边界，以及何时应该抽取脚本、何时值得引入 MCP。

如何实现一次 Agent 工具调用

Tue, 13 Oct 2026 00:00:00 +0000

这篇文章只记录 Agent 工具调用的最小闭环：声明工具 schema、接收 function_call、执行本地函数，并通过 function_call_output 继续下一次模型决策。

LeetCode 1282：用户分组，从相同容量分桶到满组即输出

Sat, 10 Oct 2026 10:00:00 +0800

从用户编号与组大小的区别出发，先按容量收集再分块，逐步写出满组即输出的 Python 解法，解释列表引用陷阱、正确性与线性复杂度。

LeetCode 49：字母异位词分组，从逐组比较到构造分组键

Sat, 10 Oct 2026 10:00:00 +0800

用 Python 从两个字符串的异位词判断出发，先写出逐组扫描的正确解，再推导排序键与字符计数键，理解哈希表分组为什么成立。

LeetCode 609：在文件系统中查找重复文件，从解析记录到按内容分组

Sat, 10 Oct 2026 10:00:00 +0800

逐步解决 LeetCode 609：解析目录与文件描述，写出两两比较的正确基线，再按内容哈希分组，并分析路径拼接成本和真实文件系统的边界。

LeetCode 152：乘积最大子数组，从负数反例推导双状态动态规划

Thu, 08 Oct 2026 00:00:00 +0000

先枚举非空连续区间，再用负数反例推导最大与最小乘积状态，逐步得到常数空间的 Python 解法。

LeetCode 279：完全平方数，从剩余和推导动态规划

Thu, 08 Oct 2026 00:00:00 +0000

从最大平方数优先的失败例子出发，逐步构建递归、记忆化与迭代动态规划，求组成整数所需的最少完全平方数。

Python range() 的边界：为什么循环有时一次也不执行？

Thu, 08 Oct 2026 00:00:00 +0000

从 range(10, 7) 出发，解释 Python range() 的起点、终点和步长，理解空范围为什么不会报错，以及它如何自动跳过不需要处理的循环。

Redis 任务队列系列（1）：用 Python 和 List 实现最小生产消费模型

Thu, 08 Oct 2026 00:00:00 +0000

使用 redis-py 和 Redis List 写出一个可以运行的最小任务队列，理解 LPUSH、BRPOP、阻塞消费、FIFO 与任务丢失边界。

后台异步任务什么时候算队列：从生产者与消费者理解 Celery、Redis

Thu, 08 Oct 2026 00:00:00 +0000

从用户提交五个计算任务出发，解释后台异步执行、前端查询状态与任务队列的区别，用 Python 示例说明生产消费解耦，并讲清 Celery、Redis 和数据库队列的关系。

LeetCode 139：单词拆分，从前缀是否可达开始

Tue, 22 Sep 2026 12:00:00 +0800

题目要求

输入输出

输入：字符串 s 和字符串列表 wordDict
wordDict 中的每个元素都是一个可以使用的单词；同一个单词可以重复使用
输出：如果 s 可以被拆成一个或多个字典单词，返回 True；否则返回 False
拆分必须覆盖整个字符串，不能跳过字符，也不能改变字符顺序

示例

输入：s = "leetcode", wordDict = ["leet", "code"]
输出：True
解释："leetcode" 可以拆成 "leet" + "code"

输入：s = "applepenapple", wordDict = ["apple", "pen"]
输出：True
解释："apple" + "pen" + "apple"；同一个单词可以重复使用

输入：s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出：False
解释：前面可以拼出一些片段，但最后不能覆盖完整字符串

约束

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 只包含小写英文字母
wordDict 中的单词互不相同

Step 1：先让“已完成的前缀”变得可见

先只问一个具体问题：对于 s = "leetcode"，在确认整串能否拆开之前，我们能不能先记录“已经拆完了哪一段”？

LeetCode 213：打家劫舍 II，环形拆成两个线性问题

Tue, 22 Sep 2026 10:00:00 +0800

题目要求

输入输出

输入：整数数组 nums，nums[i] 表示第 i 间房子的金额。
房子首尾相连，不能偷相邻的两间房子，因此第 0 间和第 n - 1 间也不能同时偷。
输出：在不触发警报的前提下，最多能偷到的金额。
约束：1 <= nums.length <= 100，0 <= nums[i] <= 1000。

示例

输入：nums = [2,3,2]
输出：3
解释：第 0 间和第 2 间首尾相邻，不能同时偷；选择金额 3 的房子。

输入：nums = [1,2,3,1]
输出：4
解释：可以偷下标 0 和下标 2，也可以偷下标 1 和下标 3。

输入：nums = [1,2,3]
输出：3

这篇只用 Python，先从最小的首尾冲突开始。

Step 1：先处理首尾相邻的冲突

先问一个具体问题：nums = [2,3,2] 时，能不能沿用直线街道的做法，直接在整个数组上选择不相邻的房子？

当前基线只有一条规则：相邻房子不能同时偷。若把这三个数当成直线，可能会把下标 0 和下标 2 当成彼此不相邻，从而错误地选择两端，得到金额 4。

这在环形输入上就会失败：首尾也相邻，0 和 2 必须互斥。要消除这一个冲突，只增加一个分支规则：任何合法方案至少属于下面一个候选分支。

LeetCode 322：零钱兑换，从更小金额推出完全背包 DP

Tue, 22 Sep 2026 00:00:00 +0000

从零钱兑换中的贪心失败和更小金额问题出发，逐步构建求最少硬币数量的完全背包动态规划。

LeetCode 300：最长递增子序列，从“以 i 结尾”推出序列 DP

Tue, 22 Sep 2026 00:00:00 +0800

题目要求

输入输出

输入：整数数组 nums
输出：返回 nums 的最长严格递增子序列长度
子序列保持原数组中的相对顺序，但不要求连续，可以跳过元素
如果选择的下标是 i_1 < i_2 < ... < i_k，还必须满足 nums[i_1] < nums[i_2] < ... < nums[i_k]
子序列非空，因此至少选择一个元素
约束：1 <= nums.length <= 2500，-10^4 <= nums[i] <= 10^4

示例

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：[2,5,7,101] 是一个长度为 4 的严格递增子序列；它不要求在原数组中连续。

输入：nums = [0,1,0,3,2,3]
输出：4
解释：[0,1,2,3] 的长度为 4；`[0,1,3]` 也是合法但更短的选择。

这篇只用 Python，从“每个位置结尾能形成多长”这个局部问题开始，逐步写出可运行解法。

Step 1：先问“以哪个位置结束？”

先看第一个例子：

下标： 0 1 2 3 4 5 6 7
数值： 10 9 2 5 3 7 101 18

答案 [2,5,7,101] 跳过了 9 和 3。当我们走到值为 7 的位置时，不能只问“它左边相邻的数是谁”，而要问：

LeetCode 416：分割等和子集，从目标总和推到 0/1 背包倒序遍历

Tue, 22 Sep 2026 00:00:00 +0800

从分割等和子集的题目压力出发，逐步建立 0/1 背包状态，并解释为什么一维压缩必须倒序遍历。

Python 中 @staticmethod 和 @abstractmethod 的区别

Wed, 09 Sep 2026 00:00:00 +0000

理解 @staticmethod 与 @abstractmethod 解决的问题，掌握实例方法、静态方法、类方法和抽象方法的选择方式。

让领域模型和仓储模型各自负责

Wed, 09 Sep 2026 00:00:00 +0000

用清晰的边界分开领域模型、仓储契约、ORM 模型和 API 模型，让业务规则不被数据库和接口绑架。

JSON 不只是键值对：Python 列表如何映射到 SQLAlchemy JSON 列

Tue, 08 Sep 2026 10:30:00 +0800

从一个关键词订阅的 Repository 示例出发，解释 JSON 对象与数组、Python list 与 tuple 的转换边界，以及 SQLAlchemy JSON 列的持久化和原地修改注意事项。

Python 类型标注中的 tuple[T, ...]：任意长度和固定长度

Tue, 08 Sep 2026 00:00:00 +0000

通过 ParsedDocument 的 blocks 字段，解释 Python 中 tuple[T, ...]、tuple[T] 和 tuple[T1, T2] 的区别，以及什么时候应该使用 tuple 或 list。

Python 中 if not value 与 is None 的区别

Tue, 08 Sep 2026 00:00:00 +0000

从逐行解析文档的空行过滤代码出发，解释 Python 中 if not value 与 value is None 的语义差异、适用边界和常见误区。

看懂 C# 的 Task<(T1, T2)>：从返回值、命名元组到 async/await

Tue, 01 Sep 2026 09:00:00 +0800

用一个可运行的 .NET 8 示例逐层讲清 C# 命名元组、泛型任务、异步等待、类型推断，以及如何阅读复杂的异步方法签名。

Python 字符串为什么不可变：从 replace 到变量重绑定

Fri, 28 Aug 2026 00:00:00 +0000

用可运行示例解释 Python str 的不可变性，区分字符串对象不变与变量重新赋值，并说明 replace、切片、+= 和循环拼接的真实行为。

先做信息对等，再谈模型能力：Agent 失败时该优化系统还是模型

Fri, 28 Aug 2026 00:00:00 +0000

Agent 做错判断时，不要先凭感觉升级模型或增加工作流。先冻结模型实际可见的输入，再用同输入可解性、信息增量和输出唯一性三项测试定位问题究竟在推理侧、系统侧还是任务契约。

从 Python/Linux 到 C#/.NET：为 Windows Runner 建立第一套心智模型

Wed, 26 Aug 2026 16:00:00 +0800

从 Windows Runner 场景入门 C# 与 .NET 8：理解 SDK、Runtime、CLR、NuGet 和 csproj，在 Ubuntu/WSL 中创建、编译并运行第一个控制台项目，并分清 Linux 开发与 Windows UKey 验收的边界。

管线只负责一次运行：文档索引系统不该默认共享跨 Run 节点

Wed, 26 Aug 2026 00:00:00 +0000

一次 RAG 与知识图谱独立运行模式的架构讨论，让我重新分清了 Pipeline、Run、动态 Target 和跨请求 Singleflight。我的结论是：文档索引系统更适合让每次 Run 独立拥有状态和节点，同一文件只保留一个活动 Run，并通过持久化产物复用结果，而不是共享正在执行的节点任务。

Speculative Decoding 为什么能加速：从并行验证到 GPU Memory-Bound

Wed, 26 Aug 2026 00:00:00 +0800

从自回归生成的串行依赖出发，解释 speculative decoding 如何用一次 Target forward 并行验证多个 Draft token，以及 acceptance rate、batch 和 KV Cache 如何决定实际收益。

LeetCode 155：最小栈，如何让最小值跟着栈一起变化

Fri, 21 Aug 2026 00:00:00 +0000

从弹出当前最小值后必须恢复历史最小值的压力出发，逐步构建 LeetCode 155 Min Stack。

LeetCode 20：有效的括号，为什么数量相同仍然无效

Fri, 21 Aug 2026 00:00:00 +0000

从反例 ([)] 出发，区分括号数量相同与括号类型、闭合顺序真正匹配，为 LeetCode 20 建立可验证的题意基础。

LeetCode 394：字符串解码，如何保存并恢复嵌套上下文

Fri, 21 Aug 2026 00:00:00 +0000

从嵌套编码会打断外层解码的压力出发，逐步构建 LeetCode 394 Decode String。

从复合意图到可执行查询：面向实体的多源证据编排

Mon, 17 Aug 2026 12:00:00 +0800

介绍一种面向实体的多源证据编排模式：将复合意图转换为语义查询计划，经实体绑定和任务展开后调用不同数据源，最后按主体组装可追溯结果。

二分查找区间怎么选：从候选集合到边界更新

Fri, 14 Aug 2026 00:00:00 +0000

从候选集合出发，理解二分查找的闭区间、左闭右开区间和开区间哨兵写法，以及初始化、循环条件与边界更新为什么必须配套。

LeetCode 74：搜索二维矩阵

Thu, 13 Aug 2026 00:00:00 +0000

给你一个 m x n 的整数矩阵 matrix 和一个整数 target。如果 target 在矩阵中，返回 True；否则返回 False。

题目给出的矩阵满足两个条件：

每一行都按非递减顺序排列。
每一行的第一个整数都严格大于上一行的最后一个整数。

要求算法的时间复杂度为 O(log(m * n))。

例如，对于下面的矩阵：

1 3 5 7
10 11 16 20
23 30 34 60

target = 3 时返回 True。
target = 13 时返回 False。

约束如下：

1 <= m, n <= 100
-10^4 <= matrix[i][j], target <= 10^4

LeetCode 提供的方法签名是：

class Solution:
 def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
 pass

第一步：扫描每一个元素

现在只有题目条件和方法签名，还没有一段能判断目标值是否存在的代码。先解决最基本的问题：怎样得到一个可以直接运行、结果确定正确的版本？

当前基线无法对示例中的 3 或 13 给出答案。加入一层遍历每一行的循环，再在当前行中检查每一个值。遇到目标值就立即返回 True；只有检查完所有元素仍未命中时，才返回 False。

LeetCode 153：寻找旋转排序数组中的最小值

Tue, 28 Jul 2026 16:13:57 +0800

从线性扫描基线推导包含最小值的闭区间与二分更新，在 O(log n) 时间、O(1) 额外空间内返回旋转数组的最小值。

LeetCode 33：搜索旋转排序数组

Tue, 28 Jul 2026 15:40:34 +0800

从线性扫描基线推导旋转数组中的有序半区与目标范围判断，在 O(log n) 时间、O(1) 额外空间内完成搜索。

LeetCode 503：下一个更大元素 II，循环数组中的右侧到哪里结束

Mon, 20 Jul 2026 00:00:00 +0800

从循环数组的严格下一个更大元素定义出发，先写可验证的环形扫描，再推导只压入一次原始索引的线性单调栈解法。

LeetCode 84：柱状图中最大的矩形，连续区间的高度由谁决定

Mon, 20 Jul 2026 00:00:00 +0800

从连续区间的最矮柱限制出发，先构造枚举区间 baseline，再推导按柱高结算最大宽度的线性单调栈解法。

LeetCode 136：只出现一次的数字，如何在常量空间排除重复元素

Wed, 15 Jul 2026 00:00:00 +0800

从集合配对 baseline 出发，推导 XOR 抵消重复元素，在线性时间和常量额外空间内解决 LeetCode 136。

LeetCode 191：位 1 的个数，如何跳过无关的零位

Wed, 15 Jul 2026 00:00:00 +0800

从逐位右移 baseline 出发，推导 n & (n - 1) 每次清除最低位的一个 1，并用循环 invariant 证明 LeetCode 191。

LeetCode 338：比特位计数，如何复用较小数字的结果

Wed, 15 Jul 2026 00:00:00 +0800

从对 0..n 每个数字重复统计的 baseline 出发，推导 answer[i] = answer[i & (i - 1)] + 1，在线性时间内完成比特位计数。

LeetCode 739：每日温度，如何找到右侧第一个更高温度

Wed, 15 Jul 2026 00:00:00 +0800

从向右扫描的 O(n²) baseline 出发，推导维护未解决日期的单调索引栈，在线性时间内解决 LeetCode 739 每日温度。

LeetCode 45：跳跃游戏 II，从可达边界升级到最少跳数

Wed, 08 Jul 2026 00:00:00 +0800

从 LeetCode 55 的 farthest 可达边界出发，推导 LeetCode 45 跳跃游戏 II：用 current_end 表示当前跳数覆盖边界，用 farthest 表示下一跳最远覆盖，最终得到最少跳数贪心。

LeetCode 435：无重叠区间，从删除最少转成保留最多

Mon, 06 Jul 2026 00:00:00 +0800

从删除哪个区间的选择压力出发，推导 LeetCode 435 无重叠区间：先把最少删除转换成最多保留，再逐步推出按结束位置排序的区间贪心。

LeetCode 452：用最少数量的箭引爆气球，从共同交集推出区间贪心

Mon, 06 Jul 2026 00:00:00 +0800

从一支箭能覆盖哪些气球出发，推导 LeetCode 452 用最少数量的箭引爆气球：先写共同交集扫描基线，再压缩成按结束位置排序的 arrow_pos 贪心。

LeetCode 121：买卖股票的最佳时机，从历史最低价推出一次交易贪心

Fri, 03 Jul 2026 00:00:00 +0800

从买入必须早于卖出的顺序压力出发，推导 LeetCode 121 买卖股票的最佳时机：先写 O(n^2) 正确基线，再压缩成维护历史最低价的一次扫描贪心。

LeetCode 55：跳跃游戏，用最远覆盖范围判断能否到达终点

Fri, 03 Jul 2026 00:00:00 +0800

从会卡在 0 的失败样例出发，推导 LeetCode 55 跳跃游戏：先用 reachable 数组建立正确基线，再压缩成维护 farthest 最远覆盖范围的贪心。

LeetCode 200：岛屿数量，把网格陆地看成连通分量

Thu, 02 Jul 2026 00:00:00 +0800

从网格中相邻陆地的合并压力出发，用并查集推导 LeetCode 200 岛屿数量，讲清二维坐标映射、陆地初始 count、union 后 count 什么时候减少。

LeetCode 684：冗余连接，用 union 失败找到成环边

Thu, 02 Jul 2026 00:00:00 +0800

从树加一条边必然成环的压力出发，用并查集推导 LeetCode 684 冗余连接，讲清 1-indexed parent、union 返回值和为什么 union 失败就是答案。

并查集模板：find / union / count 从零推导

Tue, 30 Jun 2026 00:00:00 +0800

从一个集合合并小任务出发，推导并查集模板中的 parent、find、union、count 和路径压缩，最终得到可直接背写的 Python 模板。

LeetCode 208：实现 Trie（前缀树）模板题解析

Wed, 24 Jun 2026 17:38:48 +0800

LeetCode 208 Implement Trie 是 Trie 模板题，核心是按固定接口实现 insert、search 和 startsWith。

Trie 模板：从节点字段到插入查询 invariant

Wed, 24 Jun 2026 17:38:48 +0800

从零搭一个 Trie 模板，重点理解每个节点存什么、children 怎么走、is_end 为什么需要，以及 insert/search 的循环 invariant。

Python Callable 类型标注：怎么描述一个 handler 函数？

Wed, 03 Jun 2026 00:00:00 +0000

Python Callable 类型标注：怎么描述一个 handler 函数？

副标题： Callable[[dict[str, Any]], Any] 不是一个新类，而是在类型层面说明：这个参数是一个“能被调用的对象”，它接收什么参数，返回什么结果。

标签： Python / 类型标注 / Callable / Type Alias / Pipeline 适读人群： 正在写回调、handler、pipeline step、插件机制的 Python 开发者 阅读时间： 6 min

背景：为什么 handler 类型看起来这么长？

在 pipeline runner 里，经常会有这种 handler 表：

handlers = {
 "prepare": prepare,
 "enrich": enrich,
}

每个 handler 都接收同一个运行时上下文：

def prepare(context: dict[str, Any]) -> dict[str, bool]:
 context["prepared"] = True
 return {"prepared": True}

如果直接给 handler 表写类型，会变成：

from collections.abc import Callable, Mapping
from typing import Any

handlers: Mapping[str, Callable[[dict[str, Any]], Any]]

这一串不难，但读起来吵。它把“workflow name 到 workflow handler 的映射”写成了一段类型语法。

Python 从 dict/list 原型到稳定接口：什么时候该整理类型？

Wed, 03 Jun 2026 00:00:00 +0000

Python 从 dict/list 原型到稳定接口：什么时候该整理类型？

副标题： 验证想法时先用普通变量和 dict/list 跑通行为；模型稳定后，再把它们整理成函数参数、dataclass、helper 和类型标注。

标签： Python / 原型验证 / 类型标注 / 接口设计 / Pipeline 适读人群： 正在从脚本式代码过渡到可维护模块的 Python 开发者 阅读时间： 7 min

背景：为什么一开始不用把类型设计得很完整？

写一个新功能时，经常会卡在这个问题上：

我应该一开始就写 dataclass、class、Mapping、Callable 吗？
还是先用普通 dict/list 把行为跑通？

答案不是固定的，但有一个很实用的判断：

模型还不确定时，先用 dict/list 验证行为；
模型稳定后，再把稳定的东西整理成接口。

这不是偷懒，而是在降低错误抽象的成本。

比如你想验证一个 graph pipeline runner，最早可以只写：

graph_plans = {
 "parallel": {
 "prepare": (),
 "enrich": ("prepare",),
 "extract": ("prepare",),
 }
}

这个变量一开始不是“最终架构”，只是为了回答一个问题：

dependency map 能不能表达 prepare 之后 enrich 和 extract 同时 ready？

如果这个问题都没验证清楚，提前设计完整类层次反而会遮住真正的行为压力。

第一阶段：用普通变量验证模型

最早的脚本里，很多东西看起来像“常量”：

Python 类型标注里为什么用 Mapping、Sequence 这类抽象接口？

Wed, 03 Jun 2026 00:00:00 +0000

Python 类型标注里为什么用 Mapping、Sequence 这类抽象接口？

副标题： 当一个函数只读取配置，不修改调用方传入的字典时，用 Mapping 比直接写 dict 更能表达接口意图；同理，Iterable、Sequence 和 Callable 也在表达“我需要什么能力”。

标签： Python / 类型标注 / Mapping / Sequence / Callable / 接口设计 适读人群： 正在写 Python 配置对象、runner、pipeline、SDK 参数的开发者 阅读时间： 7 min

背景：为什么不是所有字典参数都写成 dict？

写 Python 配置型代码时，经常会有这种参数：

graph_plans = {
 "parallel": {
 "prepare": (),
 "enrich": ("prepare",),
 "extract": ("prepare",),
 }
}

如果一个 runner 只是读取它：

runner = GraphPipelineRunner(graph_plans=graph_plans, handlers=handlers)

那么类型标注可以写成：

from collections.abc import Mapping


def __init__(
 self,
 *,
 graph_plans: Mapping[str, Mapping[str, tuple[str, ...]]],
 handlers: Mapping[str, WorkflowHandler],
) -> None:
 ...

刚开始看会觉得复杂：为什么不直接写 dict？

函数命名不是取名字：它是在描述系统边界

Wed, 03 Jun 2026 00:00:00 +0000

用一个小型 graph pipeline runner 解释 get、resolve、validate、ready、skip 等函数命名如何表达行为、失败语义和副作用。

从顺序 Pipeline Runner 演进到 Graph Runner

Wed, 03 Jun 2026 00:00:00 +0800

在最小顺序 Pipeline Runner 的基础上，继续推导 graph pipeline runner：为什么 workflow list 不够用，为什么要用 dependency map、ready wave、GraphNodeRecord 和失败分支跳过。

为什么开会，以及怎么开一个有效会议

Sun, 31 May 2026 21:30:00 +0800

从目标对齐、决策、问题暴露、行动分配和会议记录出发，说明什么时候需要开会，以及怎样让会议产出明确结果。

从普通函数调用推导一个最小 Pipeline Runner

Fri, 29 May 2026 00:00:00 +0800

从普通函数调用开始，逐步推导一个最小顺序 Pipeline Runner：工程接入场景、run/step observation、共享 context、mode 解析、handler 表和 PipelineRunner.trigger。

LeetCode 547：省份数量，把邻接矩阵看成图的连通分量

Wed, 27 May 2026 00:00:00 +0800

从邻接矩阵的直接连接关系出发，把 LeetCode 547 省份数量转成无向图连通分量计数问题，再逐步推出 DFS、BFS 和并查集解法。

为什么 AI 在代码领域最先自动化

Thu, 21 May 2026 00:00:00 +0000

代码领域之所以最早得到 AI 自动化，不只是因为代码适合大模型，而是因为软件工程已经拥有版本控制、测试、增量提交和回滚机制。其他领域并不是没有评价标准，而是缺少把标准绑定到中间版本上的工作流。文章、小说、视频、3D 模型等复杂作品也能被拆解、验证、冻结和追溯；而且文字领域天然拥有经典作品、评论和写作理论作为 reference corpus。一旦这些参照物被转成任务、rubric 和 checkpoint，AI 可能比在代码领域释放出更强的能力。

Docker 容器如何使用宿主机 Clash 代理

Fri, 15 May 2026 23:50:00 +0800

记录一次 Docker 容器无法直连 OpenAI OAuth 的排障过程，并说明如何通过 host.docker.internal 复用宿主机 Clash 代理。

LeetCode 198：打家劫舍，从偷或不偷推出一维 DP

Sun, 03 May 2026 14:33:39 +0800

题目要求

输入输出

输入：整数数组 nums
nums[i] 表示第 i 间房子的金额
不能偷相邻房子
输出：返回最多能偷到的金额
约束：1 <= nums.length <= 100，0 <= nums[i] <= 400

示例

输入：nums = [1,2,3,1]
输出：4
解释：偷下标 0 和下标 2，金额 1 + 3 = 4

输入：nums = [2,7,9,3,1]
输出：12
解释：偷下标 0、2、4，金额 2 + 9 + 1 = 12

这篇只用 Python，从这个二选一冲突推出一维 DP。

从 `[1,2,3,1]` 的相邻冲突开始

看例子：

nums = [1,2,3,1]

如果偷下标 2 的房子，金额是 3，那么下标 1 和下标 3 都不能偷。如果不偷下标 2，答案可能来自前面下标 0..1 的最优结果。

所以走到某一间房时，核心选择只有两个：

LeetCode 70：爬楼梯，从 dp[i] 含义推出一维 DP

Sun, 03 May 2026 14:33:39 +0800

题目要求

输入输出

输入：整数 n
含义：爬到第 n 阶楼顶
每次可以爬 1 或 2 阶
输出：返回到达楼顶的不同走法数量
约束：1 <= n <= 45

示例

输入：n = 2
输出：2
解释：1+1，2

输入：n = 3
输出：3
解释：1+1+1，1+2，2+1

这篇只用 Python，从 dp[i] 的含义一步一步推出最终代码。

从 `n = 3` 的最后一步开始

先看最小能暴露转移的例子：

n = 3

到第 3 阶的最后一步只可能来自：

第 2 阶，再走 1 阶
第 1 阶，再走 2 阶

所以“到第 3 阶的方法数”不是凭空算出来的，而是来自两个更小的位置。

Step 1：先定义更小的问题

直接问“到第 n 阶有几种走法”太大。先定义：

dp[i] = 到达第 i 阶的方法数

注意这里的 i 是楼梯位置，不是数组下标含义上的第几个元素。

LeetCode 746：使用最小花费爬楼梯，从 top 位置推出 dp

Sun, 03 May 2026 14:33:39 +0800

题目要求

输入输出

输入：整数数组 cost
cost[i] 表示踩到第 i 阶的代价
每次可以爬 1 或 2 阶
可以从下标 0 或下标 1 开始
输出：返回到达楼顶的最小花费
约束：2 <= cost.length <= 1000，0 <= cost[i] <= 999

示例

输入：cost = [10,15,20]
输出：15
解释：从下标 1 开始，付 15 后直接到达 top

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6

从 `[10,15,20]` 的 top 位置开始

先看最小例子：

cost = [10,15,20]

楼顶不是下标 2，而是在最后一阶之后的位置，可以记为位置 3。

到达 top 位置 3 的最后一步只可能来自：

位置 2，付 cost[2]
位置 1，付 cost[1]

这题最容易错的地方就在这里：我们要求的是“到达 top 的花费”，不是“到达最后一个下标的花费”。

LeetCode 53：最大子数组和，从 dp[i] 含义推出 Kadane

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：整数数组 nums
输出：返回连续非空子数组的最大和
子数组必须连续
至少选一个元素
约束：1 <= nums.length <= 10^5，-10^4 <= nums[i] <= 10^4

示例

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：[4,-1,2,1] 的和最大，为 6

输入：nums = [1]
输出：1

这篇只用 Python，从 dp[i] 的含义一步一步推出 Kadane 算法。

从 `[-2,1,-3,4]` 的断点开始

看一个前缀例子：

nums = [-2, 1, -3, 4]

如果走到 4，有两种选择：

把前面的某个连续子数组接到 4 前面
从 4 自己重新开始

这里的关键不是“所有子数组怎么枚举”，而是：

当我们决定一个最优子数组必须以当前位置结尾时，它的来源只有两种：接上前一个位置的最优结尾，或者从当前位置重新开始。

这就是一维 DP 的入口。

Step 1：先定义一个更小的问题

直接问“整个数组的最大子数组和是多少”太大。我们先强加一个限制：

如果子数组必须以第 i 个元素结尾，它的最大和是多少？

这个值记为 dp[i]。

这里的 dp[i] 不是“前 i 个元素里的最大子数组和”。它更窄：

LeetCode 78：子集，从搜索树推出 startIndex 回溯模板

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：nums，长度 1 <= nums.length <= 10
元素范围：-10 <= nums[i] <= 10
所有元素互不相同
输出：返回 nums 的所有可能子集
顺序：结果顺序不限，子集内部不需要考虑排列顺序

示例

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

这篇只用 Python 构造一个最小可运行解法。

从 `[1,2]` 的搜索树开始

最小但有分叉的例子是：

nums = [1,2]

答案应该是：

[], [1], [1,2], [2]

注意这里没有 [2,1]。这说明问题不是“随便排列所有选择”，而是“每个元素选或不选，且同一组元素只出现一次”。

如果把构造过程画成树：

[]
|- [1]
| |- [1,2]
|- [2]

这棵树暴露出两个事实：

每个节点都是一个合法子集。
进入 [1] 之后，后面只能继续看 2，不能回头再选 1 或生成 [2,1]。

Step 1：先说清楚一个递归层在解决什么

如果当前已经选出一个 path，剩下的问题是：

从某个起点之后的元素里，继续选择若干个元素，扩展当前 path。

这个“某个起点”必须被记下来。否则 [1,2] 和 [2,1] 会从不同路径重复出现。

先写最小骨架。它只保留两个状态：

LeetCode 90：子集 II，从重复分支推出层内去重

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：nums，长度 1 <= nums.length <= 10
元素范围：-10 <= nums[i] <= 10
nums 可能有重复元素
输出：返回所有不重复子集
顺序：结果顺序不限，但同一个值序列的子集只能出现一次

示例

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

这篇只用 Python，从一个能跑但浪费的版本，一步一步过渡到排序 + 层内去重。

从 `[1,2,2]` 的重复分支开始

最小能暴露问题的例子是：

nums = [1,2,2]

如果直接照搬 78. 子集 的模板，搜索树里会出现两条不同分支：

选择下标 1 的 2 -> [2]
选择下标 2 的 2 -> [2]

这两个分支路径不同，但值序列相同，最终答案重复。

所以这题真正新增的问题不是“会不会回溯”，而是：

怎样跳过重复分支，同时保留 [2,2] 这种合法答案？

Step 1：先复用 78 的状态，看看哪里会坏

当前部分答案仍然需要 path；当前层仍然需要 start 控制只能往右选。

先写出 78 的核心版本：

def dfs(start: int) -> None:
 res.append(path.copy())

 for i in range(start, len(nums)):
 path.append(nums[i])
 dfs(i + 1)
 path.pop()

这个版本在 nums 全部互不相同时是正确的。

Attention-Based Seq2Seq：为什么会自然过渡到 Transformer

Thu, 23 Apr 2026 15:51:40 +0800

副标题 / 摘要 这篇文章专门解释一个关键过渡：为什么 fixed-length 的 seq2seq 很快会不够用，attention-based seq2seq 是怎么补上“按需读取源序列”这个能力的，以及这个思路为什么几乎会自然长成 Transformer。最后会收束到一份最小可运行的 PyTorch GRU + additive attention 实现。

从“苹果”为什么老翻不准开始

还是用这个最小翻译任务：

src: <bos> I really love green apples <eos>
tgt: <bos> 我 真的 喜欢 青 苹果 <eos>

当 decoder 走到要生成“苹果”这一步时，最理想的行为其实很明确：

它应该重点回头看源序列里的 apples
它可能顺手也看一眼 green
它不能只依赖一个已经被反复压缩过很多轮的最终隐藏状态

如果你用上一篇里那个最小 seq2seq：

encoder 把整句读完
只把最后一个 hidden_enc 交给 decoder
decoder 后面每一步都只靠这个固定长度状态和自己的历史

那么句子一长，这里就会出现一个很具体的问题：

decoder 明明需要“现在按需去看源序列的某几个位置”，但 fixed-length seq2seq 只给了它“一次性打包好的整句摘要”。

这就是 attention-based seq2seq 出现的真实压力。它不是为了“概念更高级”，而是因为 decoder 在每个时间步都需要重新决定自己该看源序列的哪里。

快速掌握地图

fixed-length seq2seq：encoder outputs -> 丢弃大部分，只保留 final hidden
attention-based seq2seq：decoder step t -> 对所有 encoder outputs 打分 -> 加权求和得到 context_t
核心收益：不同目标位置可以读取不同源位置
仍然存在的限制：encoder 和 decoder 还是循环结构，时间上依然串行
通向 Transformer 的关键桥：decoder state 作为 query，encoder outputs 作为 memory

这篇文章重点深挖的两个概念

对齐分数与上下文向量：decoder 怎样在每一步决定“该看源序列哪里”
从 attention-based seq2seq 到 Transformer 的结构映射：哪些东西被保留了，哪些东西被替换了

大师级心智模型

fixed-length seq2seq 的核心假设是：

Seq2Seq 与 Encoder-Decoder：从翻译任务到最小可运行 PyTorch 实现

Thu, 23 Apr 2026 15:27:55 +0800

副标题 / 摘要 这篇文章不把 seq2seq 和 encoder-decoder 当成术语表来讲，而是从一个最小翻译任务出发，解释为什么“输入一段序列、输出另一段序列”会自然逼出编码器和解码器的分工，最后收束成一份最小可运行的 PyTorch GRU 实现。

从一个最小翻译任务开始

假设源序列是：

<bos> I love apples <eos>

目标序列是：

<bos> 我 喜欢 苹果 <eos>

当模型要生成“苹果”时，它至少要解决三件事：

它必须知道整句英文大意，而不只是当前一个词
它必须记住自己前面已经生成了“我喜欢”
它必须按顺序一个词一个词地产生输出，而不是一次吐出整个目标序列

如果你只用一个普通分类器把源句子映射成一个类别，这个任务做不成。因为这里的输出不是一个固定标签，而是长度可变的目标序列。

所以这里天然会逼出一个更具体的数据流：

先把源序列读完，压成可传递的状态
再从 <bos> 开始，逐步生成目标序列
每生成一步，都要同时依赖“源侧信息”和“目标侧历史”

这就是 sequence-to-sequence 的最小问题形态。 seq2seq 说的是任务：输入一段序列，输出另一段序列。 encoder-decoder 说的是实现：先编码输入，再逐步解码输出。

下面不先堆名词，直接按这个压力把代码一步一步长出来。

快速掌握地图

问题形态：src -> encoder -> hidden/context -> decoder -> logits
核心目标：学习条件概率 p(y_t | y_{<t}, x)
最小实现：Embedding + GRU Encoder + GRU Decoder + output projection
何时适用：翻译、摘要、改写、问答这类“输入序列 -> 输出序列”任务
明显局限：如果所有源信息都被压进一个固定长度向量，长句子会吃力

这篇文章重点深挖的两个概念

隐藏状态交接：encoder 到底把什么交给 decoder
右移目标序列与 teacher forcing：训练时 decoder 为什么不能直接喂完整真实答案

大师级心智模型

这类模型的核心抽象不是“两个 RNN 拼起来”，而是：

Transformer 结构推导：一步一步搭出最小可运行 PyTorch 实现

Thu, 23 Apr 2026 10:13:23 +0800

副标题 / 摘要 这篇文章不把 Transformer 当成一个现成黑盒来介绍，而是直接从一个最小翻译任务开始，让需要的结构一层一层长出来，最后收束成一份最小可运行的 PyTorch encoder-decoder Transformer。

从一个最小翻译任务开始

假设源序列是：

<bos> I love apples <eos>

目标序列是：

<bos> 我 喜欢 苹果

当模型要生成“苹果”时：

它不能看目标序列里未来还没生成的位置
它需要重点读取源序列中的 apples
它可能还需要参考前面的“我喜欢”来决定当前词

所以这里天然会逼出三件事：

目标侧必须有因果约束
源侧和目标侧都需要全局读取
解码器不仅要读自己，还要读编码器输出

RNN 和 CNN 也能处理序列，但它们在长距离依赖和全并行训练上都有明显限制。所以这里真正要解决的，不只是“做一个更深的网络”，而是让任意位置能直接交互，并且显式控制信息流方向。

下面开始按这个压力一步一步长代码。

Step 1：先有输入表示，但先不谈注意力

先看一个已经分词并编号后的最小输入：

<bos> I love apples <eos>
-> [1, 15, 982, 204, 2]

这里的 1, 15, 982, 204, 2 还不是模型已经理解后的表示。它们只是词表里的编号，作用更接近“标签”或“学号”：

15 比 204 小，不代表它们语义上更接近
直接拿这种离散编号去做线性变换或点积，含义也不对

所以第一步只解决一个更具体的问题：

怎样把“词表编号”变成“模型后面可以继续计算的一组连续数值”？

这里再引入两个词：

token id：分词后查词表得到的离散编号
embedding：把每个离散编号映射成长度为 d_model 的可学习向量

先写最小版，不额外引入别的机制：

Hot100：从前序与中序遍历序列构造二叉树（Construct Binary Tree from Preorder and Inorder Traversal）索引分治 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 105 讲清前序负责定根、中序负责切左右的分工，以及如何用索引区间和哈希表把构树复杂度降到 O(n)。

Hot100：二叉树的右视图（Binary Tree Right Side View）层序遍历取每层最后一个 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 199 讲清为什么右视图等价于“每层最后一个节点”，以及按层 BFS 和右优先 DFS 两种稳定写法。

Hot100：二叉树展开为链表（Flatten Binary Tree to Linked List）反向先序重连 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 114 讲清为什么展开后的链表顺序就是先序遍历，以及如何用反向先序和 prev 指针把整棵树原地重连。

Hot100：二叉树中的最大路径和（Binary Tree Maximum Path Sum）树形 DP / 单边贡献 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 124 讲清最大路径和的关键设计：递归向上只返回单边贡献，而经过当前节点的完整路径用来更新全局答案。

Hot100：二叉搜索树中第 K 小的元素（Kth Smallest Element in a BST）中序计数 / 提前停止 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 230 讲清为什么 BST 的中序遍历天然有序，以及如何用显式栈做到边遍历边计数、命中第 k 个就提前停止。

Hot100：将有序数组转换为二叉搜索树（Convert Sorted Array to Binary Search Tree）分治选中点 ACERS 解析

Mon, 20 Apr 2026 09:37:25 +0800

围绕 LeetCode 108 讲清为什么每次选中点就能同时满足 BST 有序性和平衡性，以及索引分治写法为什么最稳定。

Hot100：二叉树的直径（Diameter of Binary Tree）树形 DP / 高度回传 ACERS 解析

Sun, 19 Apr 2026 14:52:28 +0800

围绕 LeetCode 543 讲清二叉树直径的核心：递归返回高度、在当前节点更新全局直径，以及为什么最长路径不一定只看根到叶。

Hot100：二叉树的最近公共祖先（Lowest Common Ancestor of a Binary Tree）后序返回值语义 ACERS 解析

Sun, 19 Apr 2026 14:52:28 +0800

围绕 LeetCode 236 讲清最近公共祖先的后序返回值语义：子树返回什么、什么时候当前节点成为答案、以及为什么节点自己也可以是祖先。

Hot100：验证二叉搜索树（Validate Binary Search Tree）区间约束 / 中序判序 ACERS 解析

Sun, 19 Apr 2026 14:52:28 +0800

围绕 LeetCode 98 讲清 BST 的祖先区间约束、不只和父节点比较的核心原因，以及区间递归与中序判序两种稳定写法。

Hot100：N 皇后严格增量构建教程

Sun, 19 Apr 2026 00:09:28 +0800

用严格增量构建的方式讲解 LeetCode 51 N 皇后：从最小例子、最小 DFS 骨架，到第一版正确解，再到列与对角线状态优化。

Hot100：分割回文串（Palindrome Partitioning）回溯 + 回文预处理 ACERS 解析

Sun, 19 Apr 2026 00:09:28 +0800

围绕 LeetCode 131 分割回文串，讲清“切分枚举 + 回文区间预处理”的完整推导过程，帮助你把字符串分割型回溯真正写稳。

LeetCode 216：组合总和 III（回溯 / 固定长度搜索）ACERS 解析

Fri, 17 Apr 2026 14:31:14 +0800

围绕 LeetCode 216 讲清固定长度组合搜索、1..9 有界候选集与只能使用一次的回溯写法，并从题目本身一步一步推出最终模板。

LeetCode 40：组合总和 II（回溯 / 同层去重 / 只能用一次）ACERS 解析

Fri, 17 Apr 2026 14:31:11 +0800

围绕 LeetCode 40 讲清“每个位置只能用一次”与“同层去重”的真正含义，并用一步一步推导的方式建立稳定回溯模板。

试过 MemPalace 之后，我为什么仍然选择 docs-first workflow

Fri, 10 Apr 2026 00:00:00 +0000

一次真实试用后，我把 MemPalace 和现有 docs / issue / commit 工作流逐项对比，结论是：它适合保存聊天中的长期上下文，但不适合充当正式 source of truth。

Hot100：电话号码的字母组合（Letter Combinations of a Phone Number）固定层数 DFS ACERS 解析

Thu, 02 Apr 2026 13:48:57 +0800

围绕 LeetCode 17 讲清固定层数 DFS、数字到字母映射与多语言实现。

Hot100：全排列（Permutations）used[] 状态回溯模板 ACERS 解析

Thu, 02 Apr 2026 13:48:57 +0800

围绕 LeetCode 46 全排列，讲清 used[] 状态控制、叶子收集答案与多语言实现。

Hot100：组合总和（回溯 / 剪枝 / 可重复选取）ACERS 解析

Thu, 02 Apr 2026 13:48:57 +0800

围绕 LeetCode 39 讲清组合型回溯、可重复选取、remain 状态与排序剪枝，并用一步一步构建代码的方式把模板真正学会。

先写骨架，再补细节：用契约拆解算法题与中型程序

Fri, 20 Mar 2026 14:44:10 +0800

把复杂程序拆成骨架、契约和原子状态变换：本文用 LRUCache、下单流程与反例解释为什么先写外部结构通常更稳，以及 helper 应该如何控制副作用。

克隆图：哈希表 + DFS/BFS 实现无向图深拷贝（LeetCode 133）

Thu, 19 Mar 2026 13:18:26 +0800

用原节点到新节点的映射表实现无向连通图深拷贝，覆盖 DFS 与 BFS 两种写法、环处理、正确性分析与多语言可运行实现。

Hot100：二叉树的层序遍历（Binary Tree Level Order Traversal）BFS / DFS ACERS 解析

Sun, 15 Mar 2026 21:29:44 +0800

讲透 LeetCode 102 的按层 BFS、层宽控制与 DFS depth bucket 备选方案，附工程迁移和多语言实现。

Hot100：对称二叉树（Symmetric Tree）镜像递归 / BFS ACERS 解析

Sun, 15 Mar 2026 21:29:43 +0800

围绕 LeetCode 101 讲清镜像递归、BFS 成对入队与树形结构对称校验，附工程迁移和多语言实现。

相同的树（Same Tree）同步递归 / BFS ACERS 解析

Sun, 15 Mar 2026 21:29:42 +0800

围绕 LeetCode 100 讲清同步递归比较、队列成对校验与结构等价判断，附工程迁移与多语言实现。

Hot100：翻转二叉树（Invert Binary Tree）递归 / BFS ACERS 解析

Fri, 06 Mar 2026 17:58:23 +0800

围绕 LeetCode 226 讲清树镜像变换、递归交换左右子树的本质，以及工程里的结构镜像场景。

Hot100：二叉树的最大深度（Maximum Depth of Binary Tree）DFS / BFS ACERS 解析

Fri, 06 Mar 2026 17:58:22 +0800

讲透 LeetCode 104 的深度定义、递归 DFS 与层序 BFS 两种主流解法，附工程迁移和多语言实现。

Hot100：二叉树的中序遍历（Binary Tree Inorder Traversal）递归 / 显式栈 ACERS 解析

Fri, 06 Mar 2026 17:58:21 +0800

用左-根-右模板讲透 LeetCode 94，覆盖递归、显式栈与工程迁移场景，附多语言可运行实现。

先等价迁移，再行为改造：AI 协作时代最稳的工程工作流

Thu, 05 Mar 2026 16:54:59 +0800

一套面向 AI 协作开发的双阶段工作流：先做行为等价迁移，再做行为改造，配合任务记账与 worktree 隔离，减少返工与回归。

手写一个基础消息代理：发布、订阅、重试与失败契约

Sat, 28 Feb 2026 11:03:15 +0800

从发布订阅到重试与失败契约，系统讲解基础消息代理的实现与工程边界。

Git Worktree 使用教程：同仓库并行开发多个分支

Wed, 25 Feb 2026 09:27:18 +0800

一篇讲清 Git worktree 常用命令、典型场景、常见坑与最佳实践的中文教程，适合多分支并行开发与临时 hotfix。

Docker 常用使用教程：从入门到 Compose 实战（含 save/load 与权限排障）

Thu, 12 Feb 2026 00:00:00 +0000

一篇覆盖 Docker 常用命令、Dockerfile、Compose、镜像 save/load 离线迁移与挂载权限排障的实战教程。

LeetCode 146：LRU 缓存设计（O(1)）哈希表 + 双向链表实战

Wed, 11 Feb 2026 08:02:05 +0800

LRUCache 的核心是用哈希表做 O(1) 定位、双向链表维护最近使用顺序，实现 get/put 平均 O(1)。本文按 ACERS 模板给出推导、工程应用与多语言代码。

LeetCode 138：随机链表的复制（Copy List with Random Pointer）深拷贝全解析

Wed, 11 Feb 2026 07:59:32 +0800

随机链表复制的核心是把“原节点身份”映射到“新节点身份”，再重建 next/random 指针。本文用 ACERS 结构给出思路推导、工程类比、常见坑和多语言可运行实现。

LeetCode 19：删除链表的倒数第 N 个结点（双指针一趟扫描）ACERS 全解析

Wed, 11 Feb 2026 07:56:02 +0800

从朴素两趟遍历到一趟快慢指针，系统讲清删除链表倒数第 N 个结点的思路、正确性、工程场景与多语言可运行实现。

LeetCode 2：两数相加（Add Two Numbers）链表进位从朴素到最优解

Wed, 11 Feb 2026 07:54:26 +0800

把两个逆序链表表示的非负整数相加，关键是逐位相加与进位传播。本文用 ACERS 结构讲透思路推导、工程类比与多语言可运行实现。

先定不变量与契约，再写实现：Evans/Fowler 实战法

Wed, 11 Feb 2026 07:53:37 +0800

解释“先定不变量/契约，再写实现”到底在工程上多了什么，并给出可执行的落地模板。

Hot100：排序链表（Sort List）链表归并排序 ACERS 解析

Tue, 10 Feb 2026 17:07:38 +0800

在 O(n log n) 时间内对单链表排序。本文用“快慢指针找中点 + 分治归并”给出稳定模板，并对比数组化方案、常见坑和多语言实现。

Hot100：合并K个升序链表（Merge k Sorted Lists）分治归并 O(N log k) ACERS 解析

Tue, 10 Feb 2026 17:05:53 +0800

把 LeetCode 21 的双链表归并扩展到 k 路：从朴素串行合并到分治归并，时间复杂度降到 O(N log k)，并对比最小堆方案与工程取舍，附多语言实现。

Hot100：K 个一组翻转链表（Reverse Nodes in k-Group）分组反转 ACERS 解析

Tue, 10 Feb 2026 10:01:23 +0800

在单链表中每 k 个节点为一组进行原地反转，不足 k 的尾组保持不变。本文给出哑节点 + 分组扫描 + 原地反转模板，时间 O(n)、额外空间 O(1)，附多语言实现。

反转链表 II（Reverse Linked List II）哑节点+头插法 ACERS 解析

Tue, 10 Feb 2026 09:56:14 +0800

在单链表中仅反转区间 [left, right]：用哑节点定位前驱，再用头插法原地重排，时间 O(n)、额外空间 O(1)，附工程思路与多语言实现。

.dao 域名怎么选：ICANN、ENS、Handshake 一次讲清

Tue, 10 Feb 2026 09:33:01 +0800

从传统域名体系到 Web3 命名系统，系统说明 .dao 的真实现状、可选方案、落地步骤与风险边界。

图算法专题学习路径：从 BFS 到图计算模型

Mon, 09 Feb 2026 10:14:45 +0800

图算法专题导航与推荐阅读顺序，覆盖 BFS/DFS、可达性、最短路、CC/SCC、中心性、PageRank、社区发现、子图匹配、动态图、图分区与图计算模型。

图计算模型实战：Pregel（BSP）与 GAS，PageRank/CC/并行 BFS 怎么跑

Mon, 09 Feb 2026 10:05:33 +0800

围绕图计算模型给出工程化落地框架：Pregel 与 GAS 的核心抽象、同步语义、性能边界，以及 PageRank/CC/并行 BFS 的实现与选型。

图分区算法：Edge-cut vs Vertex-cut 与 METIS 工程解析

Mon, 09 Feb 2026 10:04:05 +0800

面向生产级图数据库的图分区实战文章，覆盖 Edge-cut 与 Vertex-cut 对比、METIS 核心流程、可运行示例和工程调优清单。

动态图与增量计算：增量最短路径、增量 PageRank、连通性维护 ACERS 解析

Mon, 09 Feb 2026 10:00:28 +0800

面向真实图系统，系统讲解动态图增量算法：增量最短路径、增量 PageRank、连通性维护。重点覆盖局部重算、延迟更新、近似结果三种工程必修技巧。

社区发现入门：Louvain 与 Label Propagation 的工程化选型 ACERS 解析

Mon, 09 Feb 2026 09:59:58 +0800

围绕社区发现的三类核心用途（群体识别、图分区、冷启动分析），系统讲解 Louvain 与 Label Propagation 的原理、复杂度、工程取舍与多语言可运行实现。

子图匹配 / 模式匹配：VF2 与 Ullmann 的工程化剪枝 ACERS 解析

Mon, 09 Feb 2026 09:59:16 +0800

系统讲解 Subgraph Isomorphism（NP-hard）与 VF2/Ullmann 核心思想，重点强调工程现实：受限模式查询与候选剪枝通常比算法名称本身更重要。

图中心性三件套：Degree、Betweenness、Closeness 工程 ACERS 解析

Mon, 09 Feb 2026 09:56:11 +0800

系统讲解图中心性三大指标：Degree、Betweenness、Closeness。重点给出工程可落地结论：大多数系统优先支持 Degree 和近似 Betweenness，并说明复杂度、近似策略与上线取舍。

PageRank / Personalized PageRank：图数据库节点重要性与增量更新 ACERS 解析

Mon, 09 Feb 2026 09:54:25 +0800

系统讲解 PageRank 与 Personalized PageRank：从迭代式计算、稀疏矩阵实现到增量更新策略，覆盖推荐与影响力分析等图数据库核心场景。

k-hop 与可达性查询：BFS 限制、Reachability 索引与 2-hop Labeling ACERS 解析

Mon, 09 Feb 2026 09:52:17 +0800

围绕 k-hop 与可达性查询，系统讲解 BFS+hop 限制、为何一般不全算传递闭包、以及工程常用的位图索引/2-hop labeling 思路，并给出可运行多语言实现。

连通分量与强连通分量：Tarjan / Kosaraju 工程 ACERS 解析

Mon, 09 Feb 2026 09:50:22 +0800

系统讲解无向图 Connected Components 与有向图 SCC，重点覆盖 Tarjan（工程常用）与 Kosaraju，对应图数据库中的社区划分、子图切分与分片 hint。

最短路径三件套：BFS、Dijkstra、A* 工程实战 ACERS 解析

Mon, 09 Feb 2026 09:48:00 +0800

系统讲透最短路径三件套：无权图 BFS、非负权 Dijkstra、启发式 A*。覆盖多源 BFS、双向搜索、路径裁剪等工程优化，并附可运行代码与多语言模板。

BFS / DFS 工程入门：k-hop 查询、子图抽取与路径可达性 ACERS 解析

Mon, 09 Feb 2026 09:44:11 +0800

围绕 k-hop 查询、子图抽取、路径可达性三类高频图任务，系统讲清 BFS/DFS 的迭代模板、early stop 剪枝与 visited bitmap/bloom 选型，并附多语言可运行实现。

AI 辅助编程不黑盒：责任主线工作流实战

Sat, 07 Feb 2026 13:16:00 +0800

用一套可执行的 commit 与分支流程，把 AI 变成加速器而不是黑盒来源。

Hot100：路径和 III 前缀和 + 哈希表统计向下路径（LeetCode 437）ACERS 解析

Mon, 02 Feb 2026 22:13:45 +0800

用前缀和 + 计数哈希表在 O(n) 时间统计二叉树中和为 targetSum 的向下路径数，含推导、工程迁移与多语言实现。

Hot100：环形链表 II（Linked List Cycle II）Floyd 判环 + 定位入环点 ACERS 解析

Sun, 01 Feb 2026 21:40:21 +0800

不修改链表的前提下返回入环的第一个节点：Floyd 快慢指针先相遇判环，再从头与相遇点同步前进定位入环点；O(n) 时间、O(1) 额外空间。

Hot100：合并两个有序链表（Merge Two Sorted Lists）哨兵节点归并 ACERS 解析

Sun, 01 Feb 2026 21:40:06 +0800

用哨兵节点 + 双指针在 O(m+n) 时间把两个升序链表“拼接式”合并为一个升序链表，并对比递归写法与常见坑，附多语言可运行实现（Hot100）。

Hot100：环形链表（Linked List Cycle）Floyd 快慢指针 ACERS 解析

Sun, 01 Feb 2026 18:45:44 +0800

用 Floyd 快慢指针在 O(n) 时间、O(1) 额外空间判断单链表是否有环，并对比哈希表方案、常见坑与工程迁移，附多语言可运行实现（Hot100）。

Hot100：回文链表（Palindrome Linked List）快慢指针 + 反转后半段 O(1) 空间 ACERS 解析

Sun, 01 Feb 2026 18:44:01 +0800

判断单链表是否为回文：快慢指针定位中点、原地反转后半段并与前半段对比，最后再恢复链表；O(n) 时间、O(1) 额外空间。

Hot100：反转链表（Reverse Linked List）三指针迭代/递归 ACERS 解析

Sun, 01 Feb 2026 16:30:26 +0800

用三指针迭代在 O(n) 时间、O(1) 额外空间反转单链表，并对比递归写法与常见坑，附多语言可运行实现（Hot100）。

Hot100：相交链表（Intersection of Two Linked Lists）双指针换头 O(1) 空间 ACERS 解析

Sun, 01 Feb 2026 16:29:40 +0800

在不破坏链表结构的前提下找到两个单链表的相交起点：双指针“走完 A 再走 B”保证同步，O(m+n) 时间、O(1) 额外空间；含推导、工程迁移与多语言实现。

Hot100：搜索二维矩阵 II（Search a 2D Matrix II）右上角阶梯搜索 O(m+n) ACERS 解析

Sun, 01 Feb 2026 13:56:55 +0800

行列均升序的矩阵查找 target：从右上角出发每步排除一行或一列，O(m+n) 时间、O(1) 空间；含推导、工程迁移与多语言实现。

Hot100：螺旋矩阵（Spiral Matrix）边界收缩模拟 ACERS 解析

Sun, 01 Feb 2026 13:55:22 +0800

用“边界收缩”在 O(mn) 时间输出矩阵的顺时针螺旋序列，附工程场景、易错点与多语言实现（Hot100）。

Hot100：旋转图像（Rotate Image）转置 + 行反转实现原地 90 度旋转 ACERS 解析

Sun, 01 Feb 2026 13:51:51 +0800

顺时针旋转 n×n 矩阵 90 度：用“先转置、再反转每一行”在 O(n^2) 时间、O(1) 额外空间原地完成；含推导、工程场景与多语言实现。

矩阵置零：用首行首列做标记实现原地 O(1) 空间（LeetCode 73）

Sun, 01 Feb 2026 12:53:35 +0800

把首行首列当作标记位，在不额外开集合的前提下原地完成矩阵置零；含思路推导、常见坑与多语言实现。

Windows 双网络分流：公司 WiFi 走内网，手机 USB 共享走外网

Fri, 30 Jan 2026 08:57:22 +0800

在 Windows 上同时连接公司 WiFi 和手机 USB 网络共享，通过跃点数（metric）与静态路由实现“内网走公司、外网走手机”。

WireGuard Split Tunnel 实战：手机热点上外网，同时访问公司内网

Thu, 29 Jan 2026 16:15:21 +0800

从 0 搭建 WireGuard 内网 VPN，并用 Split Tunnel 实现“外网走手机热点、内网走 VPN”；覆盖公网/无公网两种部署与排错清单。

Tailscale 子网路由实战：外网访问公司内网的最稳方案

Thu, 29 Jan 2026 16:13:14 +0800

一篇可直接落地的 Tailscale 子网路由教程，解决无公网 IP 情况下的内网访问与分流。

一台电脑同时连公司内网和手机外网：双网络分流实战

Thu, 29 Jan 2026 16:00:40 +0800

讲清楚一台电脑如何同时访问公司内网与手机外网，覆盖 USB 共享、双 WiFi、静态路由与 VPN 分流。

请求日志一定要带 RequestId 吗？Python 成熟实践与落地指南

Thu, 29 Jan 2026 15:16:00 +0800

系统回答“日志是否需要 requestId”，并给出 Python 工业级自动注入方案、工程场景与排查流程。

Attention Is All You Need：Transformer 的核心算法与工程落地

Sun, 25 Jan 2026 20:08:41 +0800

从算法抽象、复杂度与工程约束出发，解释 Transformer 如何用注意力替代递归与卷积，并给出可运行示例与选型指南。

FlashAttention 的 MQA/GQA：共享 KV 的等价、收益与实现要点（含可运行验证）

Sun, 25 Jan 2026 12:51:15 +0800

解释 FlashAttention 如何处理 MQA/GQA：共享 KV、按组计算与内存复用策略，并附可运行示例验证等价性。

FlashAttention 为什么能 one-pass：在线 softmax（m/l）与 Tiling 的核心思想

Sun, 25 Jan 2026 12:51:14 +0800

解释 FlashAttention 的 one-pass 计算原理与 tiling 策略：在线 softmax（m,l）更新、流式累积输出、不落地 $QK^\top$ 与概率矩阵，并给出可运行的块级注意力验证与访存算账。

Softmax 工程实现与 GPU 访存优化：在线更新、融合与带宽算账（含可运行验证）

Sun, 25 Jan 2026 12:51:13 +0800

拆解 softmax 标准计算的访存问题，并给出在线 softmax 与融合实现的工程优化思路，包含可运行示例与带宽算账。

Self-Attention 计算公式与 Softmax 数值稳定：从推导到工程实现

Sun, 25 Jan 2026 12:50:33 +0800

用公式与可运行示例讲清 Self-Attention 的计算流程、softmax 的数值问题与工程实现要点。

单阶段 vs 双阶段目标检测：从候选集合到 NMS 的工程算账

Sat, 24 Jan 2026 16:36:30 +0800

系统对比单阶段与双阶段目标检测的流程、复杂度与工程场景：候选集合规模、NMS/后处理成本、focal loss 与采样策略，并给出纯 NumPy 可运行示例用于算账与验证。

Anchor-Based vs Anchor-Free：目标检测两条路线

Sat, 24 Jan 2026 16:36:19 +0800

对比 Anchor-based 与 Anchor-free 检测框架的核心差异、工程取舍与实战场景。

IoU 是什么：目标检测评估的核心指标

Sat, 24 Jan 2026 16:34:42 +0800

从公式到工程实践解释 IoU（交并比），并给出可运行示例与评估细节。

空洞卷积（Dilated Convolution）：扩大感受野的工程利器

Sat, 24 Jan 2026 16:33:00 +0800

系统讲清空洞卷积的原理、复杂度与工程应用，并给出最小 PyTorch 示例。

NMS 描述：非极大值抑制的原理与工程实践

Sat, 24 Jan 2026 16:32:59 +0800

系统讲清 NMS 的核心流程、IoU 计算与工程取舍，并给出最小 PyTorch 示例。

CNN 参数量计算：从卷积核到整网规模

Sat, 24 Jan 2026 16:28:40 +0800

系统讲清 CNN 参数量计算方法与常见陷阱，并给出最小 PyTorch 示例。

CNN、RNN、LSTM 与 Transformer 的区别与适用场景

Sat, 24 Jan 2026 16:28:18 +0800

从依赖路径长度与资源复杂度两个核心概念出发，系统对比 CNN、RNN、LSTM 与 Transformer，并给出可运行示例与工程选型步骤。

动量（Momentum）优化的过程：从直觉到公式

Sat, 24 Jan 2026 16:28:18 +0800

解释动量优化的更新过程、直觉与工程取舍，并给出最小 PyTorch 示例。

优化器的了解：从 SGD 到 Adam 的工程取舍

Sat, 24 Jan 2026 16:27:20 +0800

系统讲清常见优化器原理与工程取舍，含最小 PyTorch 示例与实践建议。

图像自编码是怎么做的：原理、流程与最小实现

Sat, 24 Jan 2026 16:26:15 +0800

系统讲清图像自编码的结构、训练目标与工程场景，并给出最小 PyTorch 示例。

ViT 结构描述：从 Patch Embedding 到 Transformer 编码器

Sat, 24 Jan 2026 16:25:35 +0800

系统讲清 ViT 的结构组件、工作流程与工程实践，并给出最小 PyTorch 示例。

BN 与 Dropout：训练与推理时的关键区别

Sat, 24 Jan 2026 16:24:44 +0800

系统对比 BatchNorm 与 Dropout 在训练/推理阶段的行为差异，并提供最小 PyTorch 示例。

Transformer 中可以用 BatchNorm 吗？

Sat, 24 Jan 2026 16:24:03 +0800

讨论 Transformer 使用 BatchNorm 的可行性、限制与工程取舍，并给出最小示例。

BN 与 LN 的区别：训练稳定性与工程取舍

Sat, 24 Jan 2026 16:23:47 +0800

对比 BatchNorm 与 LayerNorm 的原理、适用场景与工程代价，并提供最小 PyTorch 示例。

为什么注意力要除以 √(d_k)：从数值稳定到工程收益

Sat, 24 Jan 2026 16:22:25 +0800

解释注意力中 QK^T 为何需要除以 √(d_k)，并给出最小 PyTorch 示例与工程场景。

残差连接的作用：为什么深度网络离不开它

Sat, 24 Jan 2026 16:22:22 +0800

解释残差连接在深度网络中的作用与原理，并提供最小可运行示例。

Attention 的复杂度与为什么需要位置编码

Sat, 24 Jan 2026 16:21:51 +0800

解释注意力的时间/空间复杂度，并说明位置编码对序列建模的必要性，含最小示例。

为什么使用多头注意力机制：能力、稳定性与工程取舍

Sat, 24 Jan 2026 16:20:59 +0800

用 ACERS 框架解释多头注意力的必要性、核心原理与工程场景，并给出最小可运行示例。

为什么 GPT 是 Decoder-Only：自回归生成的最佳形态

Sat, 24 Jan 2026 16:15:34 +0800

解释 GPT 选择 decoder-only 结构的原因，并与 encoder-only / encoder-decoder 做工程对比。

BERT vs GPT：预训练任务与应用差异

Sat, 24 Jan 2026 16:12:12 +0800

对比 BERT 与 GPT 的预训练目标、架构假设与工程场景，并给出最小可运行示例。

SGD vs Adam：优化器原理与工程取舍

Sat, 24 Jan 2026 16:12:12 +0800

对比 SGD 与 Adam 的原理、收敛特性与应用场景，并提供最小 PyTorch 示例。

LoRA 初始化的常见方法与工程取舍

Sat, 24 Jan 2026 16:00:02 +0800

系统对比 LoRA 的常见初始化方式，并给出最小 PyTorch 示例与工程实践建议。

LLaMA 中 RMSNorm 相比 LayerNorm 的优势

Sat, 24 Jan 2026 15:52:58 +0800

从公式、复杂度与工程实践出发，解析 LLaMA 选择 RMSNorm 的原因，并给出最小 PyTorch 示例。

Go 并发机制一文通：goroutine、channel、同步/异步与典型场景

Sat, 24 Jan 2026 15:47:15 +0800

系统讲清 Go 并发的核心机制与同步/异步差异，并通过真实场景给出可运行示例与实践建议。

Self-Attention vs Cross-Attention：机制、差异与工程应用

Sat, 24 Jan 2026 15:44:12 +0800

用 ACERS 框架讲清 self-attention 与 cross-attention 的核心差异、公式与工程场景。

闭包和类的共同点：为什么它们都能“携带状态”

Sat, 24 Jan 2026 15:42:47 +0800

对比闭包与类的共同点与差异，解释它们如何封装状态。

什么时候适用函数式语言：场景与边界

Sat, 24 Jan 2026 15:42:47 +0800

讨论函数式语言的适用场景、优势与限制。

为什么函数式编程越来越受关注

Sat, 24 Jan 2026 15:42:47 +0800

从并发、可靠性与工程规模角度解释函数式编程的流行原因。

用多态替换 if：把流程判断变成对象职责

Sat, 24 Jan 2026 15:42:47 +0800

通过对象职责拆分，消除重复 if 判断。

用多态替换 switch：让代码更符合开闭原则

Sat, 24 Jan 2026 15:42:47 +0800

通过策略模式消除 switch 语句，降低分支扩展成本。

BLIP/BLIP-2 实战原理与最小推理示例

Sat, 24 Jan 2026 15:40:51 +0800

按 ACERS 结构讲清 BLIP 与 BLIP-2 的原理差异，并给出最小 PyTorch 推理示例。

BLIP 与 BLIP-2 架构和区别：从对齐到生成

Sat, 24 Jan 2026 15:35:34 +0800

用结构化视角解释 BLIP 与 BLIP-2 的训练目标、模块设计与工程差异。

“现在请你面试我”：如何把开放式问题变成结构化对话

Sat, 24 Jan 2026 15:35:03 +0800

提供把开放式问题转化为结构化面试的提问框架。

10 年后的你：如何用技术规划长期成长

Sat, 24 Jan 2026 15:35:03 +0800

用工程视角回答“10 年后的你”，并给出成长路径框架。

把镜子放在扫描仪上会发生什么？背后的物理与设计

Sat, 24 Jan 2026 15:35:03 +0800

从光学原理解释“镜子放在扫描仪上”的结果，并延伸到产品设计思维。

老板让你撒谎怎么办：原则、边界与应对

Sat, 24 Jan 2026 15:35:03 +0800

从职业伦理与风险控制角度回答“被要求撒谎”的问题。

如果能穿越回去：给年轻自己的技术建议

Sat, 24 Jan 2026 15:35:03 +0800

用工程视角给出可执行的长期成长建议。

如果上司是你的克隆人，你愿意共事吗？

Sat, 24 Jan 2026 15:35:03 +0800

从协作、反馈与角色关系角度分析“克隆上司”的开放式问题。

如果我是你老板被解雇，你会如何通知我？

Sat, 24 Jan 2026 15:35:03 +0800

从尊重、透明与风险控制角度回答“解雇通知”的开放式问题。

为 COBOL 辩护：为什么老语言仍有价值

Sat, 24 Jan 2026 15:35:03 +0800

从稳定性、领域适配与成本角度讨论 COBOL 的价值。

为什么 Quora 的回答质量更好：机制与激励

Sat, 24 Jan 2026 15:35:03 +0800

从产品机制与激励设计解释 Quora 与 Yahoo Answers 的差异。

重构还是重写：如何评估系统演进路径

Sat, 24 Jan 2026 15:35:03 +0800

给出重构 vs 重写的决策框架，避免拍脑袋。

Active Record 的限制与缺陷：为什么它不适合复杂领域

Sat, 24 Jan 2026 15:29:20 +0800

分析 Active Record 模式的局限性，并给出适用边界与替代方案。

Java 栈的内存泄漏：为什么 pop 之后仍然占用

Sat, 24 Jan 2026 15:29:20 +0800

通过经典栈实现示例解释 Java 的内存泄漏与修复方式。

JavaScript for 循环闭包陷阱：为什么会打印 3

Sat, 24 Jan 2026 15:29:20 +0800

解释 for 循环中的闭包问题，并给出正确修复方式。

从循环到递归：如何避免可变状态

Sat, 24 Jan 2026 15:29:20 +0800

演示把循环转换成递归的思路，并说明如何减少可变状态。

类型擦除示例：为什么 ArrayList 与 ArrayList 相等

Sat, 24 Jan 2026 15:29:20 +0800

解释 Java 类型擦除的机制与常见误区。

如何重构嵌套错误码：从深层 if 到清晰流程

Sat, 24 Jan 2026 15:29:20 +0800

用早返回与小函数拆分重构深层嵌套错误处理。

设计 vs 架构：范围、抽象层级与责任

Sat, 24 Jan 2026 15:29:20 +0800

从范围与抽象层级解释设计与架构的区别。

数据抽象被破坏的例子：为什么实现细节不该外泄

Sat, 24 Jan 2026 15:29:20 +0800

通过示例说明数据抽象被破坏的后果，并给出修复方法。

为什么 Git/Mercurial 的合并比 SVN/CVS 更容易

Sat, 24 Jan 2026 15:29:20 +0800

从历史模型与合并算法解释分布式版本控制系统的优势。

为什么事件驱动架构能提升可扩展性

Sat, 24 Jan 2026 15:29:20 +0800

解释事件驱动架构的扩展优势、适用场景与工程取舍。

我最喜欢的语言的三个缺陷：以 Python 为例

Sat, 24 Jan 2026 15:29:20 +0800

从工程角度分析 Python 的三大缺陷及其应对策略。

本周我学到了什么：工程师的复盘模板

Sat, 24 Jan 2026 13:35:15 +0800

给出每周学习复盘的结构化模板，帮助持续成长。

浏览器公司如何盈利：产品入口与商业化路径

Sat, 24 Jan 2026 13:35:15 +0800

解释浏览器厂商的主要盈利模式与产品策略。

敏捷宣言的两句核心话：个体与协作的优先级

Sat, 24 Jan 2026 13:35:15 +0800

讨论“个体与交互重于过程和工具”“客户协作重于合同谈判”的含义与落地方式。

设计、美学与功能性的关系：如何做取舍

Sat, 24 Jan 2026 13:35:15 +0800

讨论设计、美学与功能之间的关系，并给出可操作的取舍原则。

设计中的美学元素：朋友还是敌人？

Sat, 24 Jan 2026 13:35:15 +0800

讨论美学在产品设计中的作用、风险与平衡。

项目经理有用吗：角色价值与协作边界

Sat, 24 Jan 2026 13:35:15 +0800

讨论项目经理的价值、风险与协作方式。

只有一周能改善同事生活？可落地的工程清单

Sat, 24 Jan 2026 13:35:15 +0800

给出一周内可交付的工程改进清单，提升团队日常体验。

最近读过的 5 本书：工程师视角的清单

Sat, 24 Jan 2026 13:35:15 +0800

给出工程师常读的 5 本书清单，并说明适用场景。

作为 CTO 你会如何决策：从战略到执行的框架

Sat, 24 Jan 2026 13:35:15 +0800

提供 CTO 视角下的决策框架：业务、架构、组织与风险。

“喜欢这个的人也喜欢…”：电商推荐的最小实现