企业官网建设流程全解析

玩过《赛博朋克 2077》的人，对那个每次黑入终端都要跳出来的代码矩阵解密界面一定不陌生——屏幕上一片十六进制码的方格，右边挂着一串待匹配的序列，底下一条缓冲区进度条在倒数计时。很多人第一次遇到它都是瞎点，点完了发现只拿到一个数据点，剩下的序列全废了。我前后断断续续刷了三百多小时，中间有段时间专门把代码矩阵解密（Breach Protocol）当成一个小题目来研究，写了一个求解器去穷举所有合法路径，找收益最大的那条。这篇文章就是把这套东西完整讲一遍：从规则拆解、数学建模、搜索算法设计，到完整可跑的 Python 实现，再到不用代码也能在实机倒计时里稳住手的手动套路。不管你是想收藏一个能直接抄的脚本，还是想彻底搞懂这一类"带约束的路径搜索"问题，都能拿到能用的东西。

1. 代码矩阵解密到底在解什么：规则拆解与难点定位

1.1 三个核心概念：矩阵、序列、缓冲区

先把规则讲清楚，不然后面全是空的。代码矩阵解密界面里只有三样东西需要关心。

第一是代码矩阵本身。它是一块 N×N 的方格，N 从 4 到 6 不等，入侵的目标越硬，矩阵越大。每个格子里放着一个两字符的十六进制码，常见的有1C、55、7A、BD、E9、FF这些。游戏里它是纯随机的，同一个终端重开一次位置就全变了，所以背答案没有任何意义。

第二是序列（Sequence），挂在矩阵旁边，每条长度 2 到 4 个码不等，后面跟着对应的奖励，比如"数据点 +3"、"组件 +1"、"降低追踪等级"。序列是你要去"匹配"的目标。这里有个极其关键、但被大量玩家误解的点：序列不需要从路径的第一个字符开始匹配，只要在路径字符串里连续出现就行。也就是说，如果序列是1C 55 7A，你的路径是BD 1C 55 7A E9，那这条序列照样算完成。这个性质直接决定了后面算法怎么建。

第三是缓冲区（Buffer Size），也就是你最多能选多少个格子。它由你装的网络接入仓决定，通常在 7 到 9 之间。缓冲区用完，或者序列全部完成，小游戏结束。

1.2 选择规则才是真正的约束

选格子的规则看着简单，实际是整个问题的骨架。我把它拆成四条：

• 第一步必须在第一行任选一个格子；
• 之后每一步必须和上一步在同一行或同一列，并且方向和上一步交替——也就是说，如果你上一次是纵向移动过来的，下一步就必须横向走；
• 同一个格子不能重复选择；
• 路径字符串按选择顺序拼接，序列以连续子串形式匹配。

第二条是最容易被忽略的。很多攻略只说"要横竖交替"，但没讲清楚它的后果：你的整条路径是一条蛇形折线，每一段都严格落在某一行或某一列上，而且相邻两段互相垂直。这也意味着路径不可能自交——因为交叉点就是那个会被重复走的格子。

再补充一个细节：一条序列完成了就完成了，后面路径里再出现同样的序列不会重复给分。所以收益只在"完成"那一刻结算一次。

1.3 为什么手点很难，难在哪

很多人以为自己点得慢是手速问题，其实不是。真正的问题是决策点太多而且不可撤销。以 5×5 矩阵、缓冲区 8 为例，第一步有 5 个起点，之后每一步的候选格子在 4 到 8 个之间浮动。粗算一下，总的合法路径数量在百万级别。你在两三秒的思考时间里，要在这百万条路径里挑出收益最大的那条，靠直觉基本是碰运气。

更麻烦的是局部最优会骗人。有些路径前面三个码完美匹配一条高价值序列，走到第四个码发现缓冲区不够，或者剩下的格子里根本没有下一个码。这时候你没法回退，只能眼睁睁看着奖励溜走。我自己就干过这种蠢事：盯上了"降低追踪等级"那条四码序列，一路点下去，点到最后发现缓冲区只剩一格，序列还差一个码。

所以这事本质上不是操作问题，是搜索问题。把它翻译成算法语言，就是："在一张带方向交替约束的图上，找一条长度不超过 buffer 的简单路径，使得路径字符串覆盖的序列奖励总和最大。"

2. 算法建模：为什么我最终选了 KMP 自动机加回溯搜索

2.1 一个关键简化：收益只跟路径字符串有关

动手写代码之前，先做个简化，这一步能省掉大量麻烦。

注意，最终结算的奖励，只取决于两件事：路径字符串长什么样，以及它包含了哪些序列。至于你是用什么顺序、从哪个起点走到这条字符串的，游戏完全不关心。所以整个问题的目标函数可以写成：

score(path) = Σ reward(i) 其中 序列 i 是 path 字符串的连续子串，且只计一次

这就把一个"几何路径问题"转化成了一个"字符串覆盖问题"。搜索空间还是那么大，但状态评估变得非常便宜——不需要维护复杂的几何关系，只需要维护字符串和匹配进度。

2.2 子串匹配不能用 startswith，KMP 自动机怎么接进来

接着上面那个"子串"性质说。我在路径上每走一步，都要判断每条序列的匹配进度，而且这个进度必须支持回退。

举个具体的例子。序列是1C 55 7A，路径到目前为止是1C 55 1C。这时候进度应该是什么？如果只看开头，前两个码1C 55匹配上了，第三个码是1C不是7A，看起来是"断了，归零"。但其实是错的——路径最后那个1C正好是序列的第一个码，进度应该回退到 1，而不是 0。再走一个55，进度就到 2；再走7A，序列完成。

这个"回退到最长真前缀"的行为，就是 KMP 的失配函数在干的事。所以我直接给每条序列建一个 KMP 自动机，状态是0..L（L 是序列长度），状态L就是接受态。

def build_matcher(pattern): """给一条序列建 KMP 自动机，返回 (长度, 转移函数)""" L = len(pattern) fail = [0] * (L + 1) k = 0 for i in range(1, L): while k and pattern[i] != pattern[k]: k = fail[k] if pattern[i] == pattern[k]: k += 1 fail[i + 1] = k def step(state, ch): if state == L: # 已完成，从最长真前缀继续 state = fail[L] while state and pattern[state] != ch: state = fail[state] if pattern[state] == ch: state += 1 return state return L, step

这里的step就是核心。它把"当前匹配到第几个字符"压缩成一个整数，每走一步更新一次，成本是常数级。这比每次重新扫一遍整条路径字符串快得多，尤其是搜索树很深的时候。

2.3 为什么不用 BFS 或者最短路那套

有朋友可能会问，这不就是个路径搜索吗，上 BFS 或者 Dijkstra 不就完了。

问题出在状态里必须包含"已经走过哪些格子"。因为格子不能重复，所以状态至少是(当前位置, 下一步方向, 已访问集合, 各序列匹配进度)。已访问集合是一个 36 位的位掩码（6×6 矩阵），光这一项就把状态空间撑到了天文数字。而 BFS 和 Dijkstra 之所以快，前提是"同一状态的后续代价只跟状态本身有关"——在这里，已访问集合不同，能走的格子就不同，不满足最优子结构，记忆化基本失效。

所以我没有走那条路，而是用了深度优先回溯 + 上界剪枝。理由很直接：搜索深度最大也就 9 到 12 层（缓冲区大小），完全可以递归展开；而且剪枝条件在这个问题里非常强，实测能砍掉绝大部分分支。

2.4 剪枝怎么设计：两把刀足够用

我用了两层剪枝，效果已经够了，没必要再上更复杂的。

第一刀是可行性剪枝，其实我把它合并进上界计算了。对每条还没完成的序列，算出"还差几个码才能完成"，如果这个数量超过了剩余步数，那这条序列在这次搜索分支里永远不可能完成，直接从收益上界里剔除。

第二刀是上界剪枝。当前已得分数加上所有"理论上还有机会完成"的序列收益之和，如果还打不过已经找到的最优解，这条分支立刻砍掉。

def upper_bound(self, done_mask, states, remain): ub = 0 for i in range(self.n): if done_mask >> i & 1: continue L, _ = self.autos[i] if L - states[i] <= remain: # 剩余步数够得着 ub += self.seqs[i][1] return ub

这里要说清楚，这是个乐观上界——它完全不考虑格子位置和方向交替的约束，假设剩余每一步都能推进任意一条序列。乐观上界的价值在于它绝不过剪，只可能少剪一点，正确性有保证。

提示：剪枝能不能生效，跟搜索顺序关系很大。如果第一次就把最优解找出来，后面几乎所有分支都会被第二刀砍掉。所以我把搜索顺序调了一下，优先走向"能同时推进多条序列"的格子。

3. 完整实现：从矩阵录入到输出最优路径

3.1 数据结构怎么定

我把输入定义成三块，都非常直观：

• grid：二维列表，每个元素是一个两字符字符串，比如[["1C","55","7A","BD","FF"], ...]；
• sequences：列表，每一项是(token列表, 收益分数, 名字)；
• buffer_size：整数。

收益分数这里要自己定义，因为游戏里不同奖励的实际价值差别很大。我用的权重参考是这样：

权重是主观的，你可以按自己当前的流派调整。但如果只是想"总分最大"，那就都设成 1 或者按游戏显示的数值填。

3.2 核心搜索代码

下面是完整可跑的版本，依赖只有标准库：

# -*- coding: utf-8 -*- """ Cyberpunk 2077 代码矩阵解密最优解求解器 输入：矩阵、序列、缓冲区大小 输出：最大收益、最优路径（按选择顺序编号）、完成的序列 """ def build_matcher(pattern): L = len(pattern) fail = [0] * (L + 1) k = 0 for i in range(1, L): while k and pattern[i] != pattern[k]: k = fail[k] if pattern[i] == pattern[k]: k += 1 fail[i + 1] = k def step(state, ch): if state == L: state = fail[L] while state and pattern[state] != ch: state = fail[state] if pattern[state] == ch: state += 1 return state return L, step class BreachSolver: def __init__(self, grid, sequences, buffer_size): self.grid = grid self.rows = len(grid) self.cols = len(grid[0]) self.buffer = buffer_size self.seqs = sequences self.n = len(sequences) self.autos = [build_matcher(s[0]) for s in sequences] self.best_score = -1 self.best_len = 10 ** 9 self.best_path = [] self.best_done = 0 self.best_str = "" self.nodes = 0 def _dfs(self, r, c, axis, depth, score, states, done_mask, visited, path, s): self.nodes += 1 # 记录更优解；分数相同时优先更短路径 if score > self.best_score or (score == self.best_score and depth < self.best_len): self.best_score = score self.best_len = depth self.best_path = path[:] self.best_done = done_mask self.best_str = s if depth == self.buffer: return remain = self.buffer - depth # 上界剪枝 ub = score for i in range(self.n): if done_mask >> i & 1: continue L, _ = self.autos[i] if L - states[i] <= remain: ub += self.seqs[i][1] if ub <= self.best_score: return # 生成候选：axis=0 横向（行不变），axis=1 纵向（列不变） if axis == 0: cand = [(r, cc) for cc in range(self.cols) if cc != c and (r, cc) not in visited] else: cand = [(rr, c) for rr in range(self.rows) if rr != r and (rr, c) not in visited] # 优先走向能同时推进多条序列的格子，让剪枝更早生效 scored = [] for (nr, nc) in cand: ch = self.grid[nr][nc] hit = 0 for i in range(self.n): if done_mask >> i & 1: continue L, step = self.autos[i] if step(states[i], ch) > states[i]: hit += 1 scored.append((-hit, nr, nc)) scored.sort() for _, nr, nc in scored: ch = self.grid[nr][nc] new_states = list(states) new_done = done_mask gain = 0 for i in range(self.n): if done_mask >> i & 1: continue L, step = self.autos[i] ns = step(new_states[i], ch) new_states[i] = ns if ns == L: new_done |= 1 << i gain += self.seqs[i][1] visited.add((nr, nc)) path.append((nr, nc)) self._dfs(nr, nc, 1 - axis, depth + 1, score + gain, new_states, new_done, visited, path, s + " " + ch) path.pop() visited.remove((nr, nc)) def solve(self): for c0 in range(self.cols): ch = self.grid[0][c0] states = [0] * self.n done = 0 gain = 0 for i in range(self.n): L, step = self.autos[i] ns = step(0, ch) states[i] = ns if ns == L: done |= 1 << i gain += self.seqs[i][1] self._dfs(0, c0, 1, 1, gain, states, done, {(0, c0)}, [(0, c0)], ch) return self.best_score, self.best_path, self.best_done, self.best_str

有几个地方值得单独说一下。

axis参数的定义是"下一步的移动轴"：axis=1表示下一步纵向走（列不变），axis=0表示下一步横向走（行不变）。第一步之后传的是 1，因为第二步必须跟第一步同列。每次递归传1 - axis完成交替。

搜索顺序那段scored排序是我后来加的优化。原本是按行列自然顺序枚举候选格，节点数明显偏多。改成优先走"能让更多序列的 KMP 状态前进"的格子之后，第一次更新最优解的质量高了很多，上界剪枝的命中率肉眼可见地上升。

3.3 结果渲染：把路径按选择顺序标出来

光有坐标不够直观，我写了个渲染函数，把路径格按选择顺序加方括号，一眼就能看出蛇形走向：

def render(grid, path): order = {pos: i + 1 for i, pos in enumerate(path)} lines = [] for r in range(len(grid)): row = [] for c in range(len(grid[0])): cell = grid[r][c] if (r, c) in order: row.append("[{:>2}]".format(cell)) else: row.append(" {:>2} ".format(cell)) lines.append("".join(row)) return "\n".join(lines)

配上测试数据跑一遍：

if __name__ == "__main__": grid = [ ["1C", "55", "7A", "BD", "FF"], ["55", "E9", "1C", "7A", "55"], ["BD", "1C", "55", "E9", "7A"], ["7A", "55", "BD", "1C", "E9"], ["FF", "7A", "E9", "55", "1C"], ] sequences = [ (["1C", "55", "7A"], 3, "数据点"), (["BD", "1C"], 2, "组件"), ] solver = BreachSolver(grid, sequences, buffer_size=6) score, path, done, s = solver.solve() print("最大收益:", score) print("路径字符串:", s) print("搜索节点数:", solver.nodes) print(render(grid, path))

跑出来是 4 步拿 5 分：(0,3) BD → (3,3) 1C → (3,1) 55 → (4,1) 7A。路径字符串BD 1C 55 7A，里面BD 1C完成了组件序列，位置 2 到 4 的1C 55 7A完成了数据点序列，两条一起拿下。而这个矩阵里有一条更"顺眼"的路——第一步选(0,0) 1C，纵向到(1,0) 55，横向到(1,3) 7A，三步就完成数据点，但组件序列完全够不着，总分只有 3。所以最优解往往不在你直觉第一眼看上的那条路上。

3.4 参数录入的小技巧

实机遇到终端时，我一般不现写代码，而是提前开一个终端窗口备好脚本，然后手速录入。矩阵录入直接用每行空格分隔的方式贴进去最省事：

raw = """ 1C 55 7A BD FF ... """ grid = [line.split() for line in raw.strip().splitlines()]

5×5 的矩阵，25 个码，熟练的话十几秒能敲完。真正费时间的是重新跑脚本、读结果，所以我的做法是提前把常见序列组合也存成一个配置表，遇到就直接调用。

4. 实测与调优：不同矩阵规模下的表现

4.1 剪枝到底省了多少

在我自己的机器上（普通笔记本，CPython 3.11）跑过一组对比。5×5 矩阵、缓冲区 8、3 条序列的场景，把上界剪枝关掉，搜索节点数稳定在百万量级，跑完要一两秒；打开剪枝之后节点数掉到十万量级，基本瞬间返回。

6×6 矩阵、缓冲区 9的差别更夸张。这个规模下不做任何剪枝，搜索树的规模是千万级往上，我试过一次，等了好几秒才出结果，而且当时还是把序列数量压到 2 条才敢跑。加上上界剪枝和搜索顺序优化之后，同样配置基本都能在一秒内结束。差了两个数量级，这个投入非常值。

需要说明的是，实际耗时跟序列配置关系很大。如果三条序列的收益都很高、又都很容易完成，剪枝的边界条件会很松，搜索空间反而大；反过来，如果有一条序列几乎不可能完成，上界会很快被打穿，剪枝砍得特别狠。

4.2 更大矩阵还能怎么优化

6×6 已经是游戏里的上限了，但如果你想拿这套代码去处理更一般的版本，有几个方向可以试。

第一，换更短的编码。把每个格子映射成 0 到 15 的整数（十六进制码本来就有 16 种），KMP 自动机的转移表可以做成数组而不是字典，速度能提一截。

第二，加一个贪心预跑。在正式 DFS 之前，先用一个简单的启发式走一遍，得到一个不错的初始解，把best_score抬高，后续的剪枝阈值就更严格。我用的是"每步选能推进最多序列的那个格子"，不回溯，一次走完，成本几乎为零。

第三，收益分层的分支定界。把序列按收益降序排，先只考虑高收益序列求最优解，再逐步加入低收益序列。这个方法在序列数量多的时候有效，但我们这里最多也就三四条，收益有限，我就没实现。

第四，直接换语言。如果追求极致，把核心 DFS 用 C++ 或者 Rust 重写一遍，性能大概能再快一个数量级。不过说实话，在 6×6 这个规模上完全没必要，Python 已经够用了。

4.3 顺手加的两个实用功能

第一个是批量求解。实机闯关的时候经常连着遇到好几个终端，我加了个循环，一次把几组矩阵都丢进去，输出每组的路径，省得来回改代码。

第二个是日志记录。每次求解把矩阵、序列、最优路径、收益都写到一个文本文件里。攒多了之后我发现一件有意思的事：有些序列组合出现的频率明显偏高，而且很多矩阵的"最优路径"长度其实远小于缓冲区，也就是说缓冲区经常是过剩的。这个观察直接影响了我后来的手动策略——不要为了用满缓冲区去凑步数，够用就停。

注意：缓冲区没用完不会有任何惩罚。游戏里唯一结算的是完成了哪些序列，步数不参与评分。所以看到那些"必须点满"的说法可以直接忽略。

5. 不用代码也能玩：手动解矩阵的实战套路

5.1 三步扫描法

不是每次都想开电脑跑脚本，尤其是窝在沙发上的时候。我练出来一套三分钟能想明白的手动流程，准确率大概能到八成以上。

第一步，扫第一行。把每条序列的第一个码在矩阵第一行的位置全部圈出来。这是你唯一的起点池，圈不出来更多位置的序列，基本可以提前判死刑了。这一步很重要，因为它直接决定了哪条序列"有可能完成"，而不是浪费时间在不可能的序列上。

第二步，从起点往两个方向展开。对每一个起点，先看它所在的列（因为第二步必须纵向），找出序列第二个码的位置；找到之后，再看那个位置所在的行，找第三个码。就这么"列—行—列—行"地交替推下去。推到哪一层断了，这条路线就废了。

第三步，倒着验证缓冲区。找到一条看起来能走通的路线之后，数一下总步数，跟缓冲区比一下。如果超了，就得砍掉一些"绕路"的部分。很多时候你会发现，最优解不是最长的那条路线，而是某条短小精悍的路线刚好能同时覆盖两条序列。

用上一节那个 5×5 的矩阵演示一下。第一行是1C 55 7A BD FF，序列1C 55 7A的首码1C在(0,0)，序列BD 1C的首码BD在(0,3)。从(0,0)出发纵向看第 0 列：1C 55 BD 7A FF，第二个码55在(1,0)，很好。再从(1,0)横向看第 1 行：55 E9 1C 7A 55，第三个码7A在(1,3)。三步完成数据点，收益 3。

再从(0,3)出发纵向看第 3 列：BD 7A E9 1C E9，第二个码1C在(3,3)。到这里组件完成，收益 2，用了两步。然后从(3,3)横向看第 3 行：7A 55 BD 1C E9，想接数据点的第二个码55，在(3,1)，第四步。再从(3,1)纵向看第 1 列：55 E9 1C 55 7A，第三个码7A在(4,1)，第五步。总共五步，拿 5 分。缓冲区 6 完全够。

手动推的时候你会发现，能"顺路"接上下一条序列的格子特别值钱。这也解释了为什么我的代码里要把"优先走能推进多条序列的格子"放在搜索顺序的最前面。

5.2 什么时候该果断放弃一条序列

这是手动玩最容易犯的错误：舍不得。看到一条"降低追踪等级"摆在眼前，明知道首码在第一行的位置极偏，还是硬着头皮去追，结果把缓冲区全耗光。

我的判断标准是这么几条：

• 首码不在第一行的序列，直接放弃。第一步只能选第一行，首码如果不在第一行，这条序列永远完不成。这一条能筛掉一大半的纠结。
• 需要绕远路的序列，算一下性价比。多绕两三步只为了拿 1 分的"折扣"，不如把那几步省下来去凑另一条序列。
• 两条序列抢同一个格子的时候，比收益。这种冲突非常常见，尤其是一个关键码同时是两条序列的组成部分。
• 四码序列要慎重。长度 4 的序列在缓冲区 7 到 8 的情况下，几乎要求你整条路径都在为它服务，容错率极低。

反过来，如果一条序列三步之内能完成，而且还能顺路推进另一条，那就是必拿的。

5.3 倒计时下的心法

这游戏给的时间确实紧，尤其是后期一些终端，思考时间可能只有几秒。我的经验是：

先点第一步，边点边想。第一步几乎没有代价——所有第一行的格子都是合法起点，选一个最像能连出去的。点完之后小游戏的节奏就归你掌控了，因为每一步的选择时间相对宽松。

心里默念"列——行——列——行"。交替方向的规则在紧张时最容易忘，我曾经在关键时刻连点两个横向，直接卡死。养成默念的习惯之后就没再出过错。

别追求完美。只要能稳稳拿下一到两条高价值序列，收益就已经超过绝大多数玩家的平均水平了。为了理论最优去尝试一条五步的复杂路线，风险远大于收益。

提前准备好"垫步"。有时候你发现某一步选哪个码都推进不了任何序列，这时候选一个不冲突的格子"垫"一下，反而能把方向轴切换到需要的那个维度上。这个技巧在复杂矩阵里特别好用，很多人不知道方向轴是可以靠"废步"调整的。

6. 踩坑记录与常见问题速查

6.1 我自己踩过的几个坑

坑一：把子串匹配当成前缀匹配。最早写第一版求解器的时候，我天真地以为序列必须从路径的第一个字符开始。结果跑出来的解明显比手点的还差，排查了半天才反应过来是匹配逻辑错了。改成 KMP 之后，解法质量立刻上了一个台阶。这个问题其实很多玩家也有，手动玩的时候看到前面没对齐就直接放弃某条序列，白白丢掉收益。

坑二：忘了格子不能重复。第二版代码里我漏了visited判断，结果出现了一些"来回横跳"的诡异路径，比如(1,0) → (1,3) → (1,0)这种。虽然字符串层面看起来能匹配，但游戏里根本选不了。加上访问集合之后就好了。

坑三：方向轴初始化写反。第一步之后的第二步必须是纵向（列不变），我一开始写成了横向，导致所有解都是错的，但错得很隐蔽——它依然能给出一个"看似合理"的路径。后来我拿一个手推过的矩阵去校验，才发现了问题。所以做完代码一定用手算过的例子验证一遍，这一步不能省。

坑四：用收益相同的排序覆盖了更优解。有一版我用>=更新最优解，结果最后返回的是一条更长的路径，收益一样。虽然收益没损失，但路径难看，也浪费了缓冲区。改成"分数更高，或者分数相同但路径更短"之后就正常了。

6.2 常见问题速查表

6.3 关于手动玩的一个小结论

把求解器跑了几百个随机矩阵之后，我得到一个挺实用的结论：在 5×5 及以上的矩阵里，最优解的平均路径长度大约是缓冲区大小的 60% 到 70%。也就是说，缓冲区 8 的场景下，最优解通常在 5 到 6 步。这意味着大量玩家在手动玩的时候其实是"过度使用"缓冲区了，把步数浪费在了低价值序列上。

我自己现在的手动策略就是照着这个结论来的：优先锁定能在 5 到 6 步内完成的一到两条序列，剩下的步数如果顺手能捞点别的就捞，捞不到就停手。用这个方法之后，我在高难度终端上的数据点收益大概稳定在了以前的 1.5 倍左右，而且因为不再瞎点，心理压力小了很多，倒计时下的失误率也降下来了。

如果你也想自己写一套，我的建议是先用一个手推过的 4×4 小矩阵把代码跑通、结果对得上，再去处理 6×6 的大矩阵。中间那些方向轴、访问集合、KMP 状态的细节，随便错一个都会让结果看起来"差不多但就是不对"，用手算的样例校验是最快的排查手段。