想象你是一位负责送信的邮差，要在一个巨大的迷宫里找到通往终点的路。普通测试的方法，是随机选一条路走，走不通就退回换一条，效率低且容易错过重要岔路。而符号执行（Symbolic Execution）就像给邮差施了魔法：每到一个岔路口，他就变出一个分身，让每个分身走一条不同的路。所有分身同时前进，最终把迷宫中所有可达的路线全部记录在一张“路径地图”上。这张地图就是程序的全部执行路径，每条路是否真的走得通，由邮差大脑里的“约束求解器”来判断。 KLEE 就是一位经验丰富的“魔法邮差导师”，教会了无数分身如何在大型城市中高效探索。但魔法也有代价——岔路太多时，分身数量呈指数爆炸式增长，这就是著名的“路径爆炸”问题。聪明的做法是让分身与真身配合：分身负责深挖复杂路径，真身负责快速跑遍主干道，这就是符号执行与模糊测试的混合策略。如今，AI 的加入更让邮差学会了预测哪条路更值得走。

岗位关联

掌握符号执行，你就能读懂自动化漏洞挖掘、程序验证等工具的核心引擎，为从事软件安全与可靠性工作打下坚实根基。

目录
  1. 可视化演示
  2. 基本概念
  3. KLEE引擎
  4. 路径爆炸
  5. 约束求解
  6. 混合测试
  7. 挑战未来
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

演示符号执行核心原理：符号变量驱动的执行路径树分支、路径爆炸问题与缓解策略、符号执行与模糊测试混合方案的效果对比。

本节配有交互动效（进入视口后自动加载，约 3KB）。

符号执行路径树 符号变量替代具体输入，沿条件分支探索所有可能路径 每个分支节点生成路径约束，约束求解器判断可行性 可行路径生成测试用例，不可行路径被剪枝 Path Constraint = ∧(branch conditions) 符号执行通过路径约束系统化探索程序行为空间

基本概念

想象你就是那位获得魔法传承的邮差。在普通世界里，送信到迷宫深处，一次只能选一条路线，走错就得退回重来。但获得魔法后，每当你站在岔路口，就能变出一个分身替你走其中一条路。所有分身身披“符号斗篷”，不携带具体地址，只携带一条数学规则。到最后，你面前就铺开了一张由所有可达路径构成的完整地图。

在程序中，这套“分身术”就是符号执行。调试程序时，我们给定具体输入（如 x=5）然后运行；符号执行则把输入变成“符号变量”——一个可以代指任何整数的数学占位符。程序执行于是变成一条条规则的累积：遇到 if (x > 0) 时，不是判断“5大于0”是否成立，而是把“x > 0”和“x ≤ 0”同时挂到两个不同的执行状态上，像两个分身各自带着约束往前走。

符号执行的核心要素有三个。第一是符号变量，用 α、β 等符号代替具体输入；第二是路径约束，它是当前分支条件的合取，记录了路径经历过的所有判断；第三是程序状态，通常写作 ⟨符号存储，PC⟩ 二元组，符号存储保存变量与符号表达式之间的映射。探索机制负责调度这些状态，可按深度优先（DFS）、广度优先（BFS）或随机策略进行。

所以，魔法邮差的“分身术”并不神秘：每个分身就是一个携带路径约束的状态，全部分身集合在一起，构成一棵程序的“路径树”。当需要在迷宫中找到某类特定路径时——比如导致程序崩溃的路径——邮差只需检查哪条路径的约束存在解，就能精准定位。

PC=(α>0)∧(β<5)\displaystyle PC = (\alpha > 0) \land (\beta < 5)
PC 表示走到当前路径必须同时满足的所有条件的“合取清单”，求解器检查它是否有解，即可知道这条路是否真的存在。
  1. 符号化输入把具体输入替换为符号变量，例如 x 变成 α、y 变成 β。
    x=α,y=β\displaystyle x = \alpha, \quad y = \beta
  2. 分支约束累积每经过一个条件分支，就把该条件追加进已有路径约束。
    PCnew=PCold∧C\displaystyle PC_{\text{new}} = PC_{\text{old}} \land C
  3. 可行性判定调用求解器检查 PC 是否有解，有解则路径可达，无解则丢弃。
    SAT(PC)⇒路径可行\displaystyle \text{SAT}(PC) \Rightarrow \text{路径可行}

KLEE引擎

有了分身术，邮差还需要一套指挥系统：众多分身谁先出发？谁已走进死胡同？谁的内存快耗尽？这就需要一个“分身调度指挥部”。KLEE 工具就是软件世界里最著名的指挥部之一，由斯坦福大学团队开发，专为 C/C++ 程序提供符号执行服务。

KLEE 的核心是三类组件协作。指令解释器逐条执行字节码指令，维护每个状态的符号存储；状态管理器决定下一个调度哪个状态，通常采用启发式策略；约束求解器（默认 STP，也支持 Z3）在状态分支时判断路径可行性。三者的协作让 KLEE 能像指挥部一样高效调度成千上万的分身。

KLEE 采用解释执行而非编译执行，因此可以精确控制每条指令的语义。处理分支指令时，当前状态被复制为两个子状态，分别追加条件 C 和 ¬C；状态管理器用搜索策略（如随机搜索、覆盖率优先搜索）决定下一个活跃状态。别名处理是另一关键点：对指针和内存地址的符号化分析，让 KLEE 能处理涉及指针操作的程序。

指挥部的调度策略直接决定“分身军团”的战斗力。如果只按顺序调度，某些深层路径可能永远到不了；覆盖率优先的策略则像邮差优先探索未走过的区域，让地图更快被填满。KLEE 的成功，正是这套调度系统在无数次实际探索中打磨出来的。

δ(⟨store,PC⟩,instr)→{⟨store,PC∧C⟩,⟨store,PC∧¬C⟩}\displaystyle \delta(\langle store, PC \rangle, instr) \to \{\langle store, PC \land C \rangle, \langle store, PC \land \lnot C \rangle\}
这条公式描述“指令执行一步，一个状态如何变成两个互斥的子状态”，就像指挥部把一个分身拆成两个带着不同路线的分身。
  1. 状态定义执行状态由符号存储和路径约束共同构成。
    S=⟨store,PC⟩\displaystyle S = \langle store, PC \rangle
  2. 指令执行执行一条指令后，产生一个或多个后继状态。
    δ(S,instr)→{S1,S2,…}\displaystyle \delta(S, instr) \to \{S_1, S_2, \ldots\}
  3. 分支分裂条件分支的两个后继状态，分别携带条件 C 和 ¬C。
    S1=⟨store,PC∧C⟩,S2=⟨store,PC∧¬C⟩\displaystyle S_1 = \langle store, PC \land C \rangle, \quad S_2 = \langle store, PC \land \lnot C \rangle

路径爆炸

魔法是有代价的。每遇到一个岔路口，分身就多出一倍。第 10 个路口后有 1024 个分身，第 20 个路口后超过 100 万个。邮差想要同时维持这么多分身，法力就会以指数速度耗尽——这就是程序分析中的“路径爆炸”问题。

路径爆炸是符号执行走向实用化的最大障碍。程序中的 if 语句、循环、函数调用都会产生分支；一个包含 k 个独立条件的程序，理论路径数就是 2^k。符号执行的优势在于“全路径探索”，但恰恰是“全路径”会被路径数量压垮。

应对路径爆炸的主流策略有四类。第一，搜索策略优化：用深度优先、随机搜索、覆盖率引导等启发式方法，优先探索“更可能发现问题”的路径。第二，剪枝技术：约束求解器返回 UNSAT 的路径直接丢弃，因为没有任何输入能走到这里。第三，状态合并：将约束相似的路径合并，压缩状态空间。第四，近似与抽象：牺牲部分精度来控制爆炸规模。

正是看到了“分身术”的致命弱点，聪明的邮差开始琢磨：能不能少分一些身，只挑最有希望的路走？于是就有了约束求解和启发式搜索，以及后来把分身与真身组合使用的“混合测试”方案。

N(k)=2k\displaystyle N(k) = 2^k
这是路径爆炸的“指数定律”：k 个独立分支就产生 2 的 k 次方条路径，k=20 时已有超过 100 万条。
  1. 单分支两路每个条件分支把一条路径拆成两条。
    P={P∧C,  P∧¬C}\displaystyle P = \{P \land C, \; P \land \lnot C\}
  2. k 个分支倍增连续 k 个独立分支，路径数指数增长。
    N(k)=2k\displaystyle N(k) = 2^k
  3. 循环放大循环体内的分支随迭代次数成倍增加。
    N=2k1×2k2×⋯=2k1+k2+⋯\displaystyle N = 2^{k_1} \times 2^{k_2} \times \cdots = 2^{k_1 + k_2 + \cdots}

约束求解

每个分身站在岔路口时，都要先问自己一个问题：“我手上这条路径约束，世界上真的存在一个输入值能同时满足吗？”如果不存在，那这条路就是死路，分身可以直接消失。负责回答这个问题的“大脑”，就是约束求解器。

约束求解器接收路径约束 PC，返回两种结果之一：SAT（可满足），并附带一组赋值样例；或 UNSAT（不可满足），表示该路径不可达。符号执行中最常用的是 SMT（可满足性模理论）求解器，如 STP 和 Z3，它们能处理整数、实数、位向量、数组等多种理论。

约束求解是符号执行中耗时最高的环节。常用优化手段包括：缓存已求解的约束结果，避免重复求解；增量求解在原有约束基础上追加新约束而非从头求解；以及约束简化，把 α+0 化简为 α。即便如此，复杂数组操作、非线性算术仍可能让求解器卡住——这是符号执行规模化时的核心瓶颈。

这个“大脑”的速度决定了分身军团的行动效率。如果大脑反应迟钝，即使分身再多也寸步难行。所以符号执行工具不惜投入大量工程精力优化求解流程——毕竟，一位聪明的邮差知道，与其派出千万分身瞎跑，不如让每个分身多问问“这条路真的走得通吗”。

∃α∈Z,β∈Z:(α>0)∧(β<5)∧(α+β=10)\displaystyle \exists \alpha \in \mathbb{Z}, \beta \in \mathbb{Z} : (\alpha > 0) \land (\beta < 5) \land (\alpha + \beta = 10)
这条公式问的是：存在整数 α 和 β，能同时让三个条件都成立吗？如果可以，这条路径就是真实的。
  1. 存在性量词询问是否存在整数 α 和 β 满足所有约束。
    ∃α,β∈Z\displaystyle \exists \alpha, \beta \in \mathbb{Z}
  2. 约束合取路径约束中的每个子条件都必须同时成立。
    (α>0)∧(β<5)∧(α+β=10)\displaystyle (\alpha > 0) \land (\beta < 5) \land (\alpha + \beta = 10)
  3. 求解输出求解器找到一组实例，例如 α=6、β=4。
    m:α↦6,  β↦4\displaystyle m: \alpha \mapsto 6, \; \beta \mapsto 4

混合测试

魔法分身虽然厉害，但终究不能无限使用。精明的邮差发现，最好的策略是“分身探路、真身快跑”：让少而精的分身去深挖复杂难走的路，同时派出真身用短跑速度把主干道快速跑一遍。这就是符号执行与模糊测试结合的混合测试。

模糊测试（Fuzzing）是一种廉价高效的测试方式：随机生成大量输入调用程序，观察是否崩溃或异常。它的优点是速度快、成本低，但对深层条件（如“x==42 且 y==7”）很难命中；符号执行恰好擅长求解这类深层分支，代价是速度慢、开销大。两者结合形成互补：模糊测试负责广度覆盖，符号执行负责深度突破。

工程实践中，混合方案最常见的是“引导式模糊测试”：先用模糊测试快速跑出覆盖基线，再用符号执行求解未覆盖分支的输入，将新输入回注到模糊测试池继续变异。著名的工具如 AFL+KLEE（以及 Driller、DigFuzz）都基于此思路。覆盖率指标用于衡量探索质量，提升覆盖率是混合测试的核心目标。

当邮差把分身术和短跑术配合起来，整个城市的送信效率大幅提升：分身研究隐藏极深的角落，真身快速扫街，两者互相补充。这套“双引擎”策略，如今已成为自动化漏洞挖掘和程序测试的主流范式。

C=NcoveredNtotal×100%\displaystyle C = \frac{N_{\text{covered}}}{N_{\text{total}}} \times 100\%
覆盖率就是“已经走过的路径数”除以“总共可达路径数”，混合测试的目标就是让这个比值尽可能接近 100%。
  1. 已覆盖路径数模糊测试与符号执行实际覆盖的路径集合大小。
    Ncovered=∣Pfuzz∪Psym∣\displaystyle N_{\text{covered}} = |P_{\text{fuzz}} \cup P_{\text{sym}}|
  2. 总路径估计程序所有可达路径的估计数量。
    Ntotal=∣Pall∣\displaystyle N_{\text{total}} = |P_{\text{all}}|
  3. 覆盖率计算两者比值反映探索的充分程度。
    C=Ncovered/Ntotal\displaystyle C = N_{\text{covered}} / N_{\text{total}}

挑战未来

城市在扩展，邮差面对的不再是精心设计的迷宫，而是混乱的、与外界连通的大都市：有河流（系统调用）、地道（外部库）、甚至天气（环境干扰）。符号执行想从实验室走进真实世界，必须面对这些复杂环境。

当前主要挑战包括：环境交互——程序会调用系统 API、读取文件、访问网络，这些外部行为难以在符号层面精确建模；组合爆炸——多个函数的调用组合让路径空间急剧膨胀；同时，浮点运算、并发线程等也带来额外困难。

未来方向中最值得期待的是与 AI 融合。传统启发式搜索依赖人工设计的规则，而机器学习可以学习“哪些路径更可能触发 bug”，从而更聪明地调度探索。例如用神经网络对程序状态打分，引导符号执行优先探索高价值路径。同时，云原生架构让大规模并行符号执行成为可能，一个大型程序可被切分成多个子任务分散到集群中运行。

来自 AI 的“智能罗盘”让魔法邮差如虎添翼——不再盲目分身，而是让直觉指引分身去哪条路。符号执行正从实验室的精密仪器，演进为软件安全领域的日常工具，与 AI 协同的探索才刚刚开始。

p∗=arg⁡max⁡p∈P  fθ(ϕ(sp))\displaystyle p^* = \arg\max_{p \in P} \; f_{\theta}(\phi(s_p))
这条公式是“AI 导航员”的核心思想：从所有待探索路径中，选出模型预测价值最高的那条优先走。
  1. 状态特征提取从执行状态中提取特征向量，供模型使用。
    ϕ(sp)∈Rd\displaystyle \phi(s_p) \in \mathbb{R}^d
  2. 价值预测AI 模型 f_θ 给每条路径打一个“探索价值”分。
    U(p)=fθ(ϕ(sp))\displaystyle U(p) = f_{\theta}(\phi(s_p))
  3. 最优选择选择得分最高的路径优先探索。
    p∗=arg⁡max⁡pU(p)\displaystyle p^* = \arg\max_{p} U(p)

AI 应用场景

安全漏洞挖掘

阶段：代码分析与漏洞检测

解决的问题：传统人工审计依赖经验、容易遗漏深层路径；模糊测试虽快，但很难穿越“x==42”这类深层条件。符号执行将输入符号化，系统求解出触发每个分支的输入，将这些输入喂给程序，就能发现崩溃、越界等安全缺陷。

具体案例：安全团队用 KLEE 分析开源图像库的解析代码，在符号执行过程中生成了导致内存越界的特殊图片文件。修复后，团队将符号执行集成进 CI 流水线，每次代码提交自动执行一轮符号探索。

智能合约审计

阶段：形式化验证与安全审计

解决的问题：区块链智能合约一旦部署就无法修改，任何漏洞都可能造成巨额损失。传统测试难以覆盖合约中所有调用组合和状态变换。符号执行可以把合约函数参数符号化，自动探索所有可能的状态路径，检测可重入攻击、整数溢出等问题。

具体案例：安全审计公司使用基于符号执行的工具（如 Mythril）对以太坊 DeFi 合约审计，在一次检测中自动发现了可被攻击者利用的重入漏洞，并生成了具体的攻击交易序列。

自动驾驶程序验证

阶段：测试与验证

解决的问题：自动驾驶决策模块包含大量条件判断和状态组合，人工构造测试用例很难覆盖各种边界情况。符号执行能针对控制算法中的复杂条件自动求解边界输入，验证系统在极端条件下的安全性。

具体案例：测试团队对车道保持模块执行符号分析，自动生成了“最小转弯半径 + 最高限速 + 湿滑路面摩擦系数”等极端参数组合，发现了一个可能导致车辆偏离车道的逻辑缺陷。

Python 演示

python60 行
"""用 Z3 求解器演示符号执行的核心流程.目标程序:    def max_abs(a, b):        if a > 0:            if b > 0:                return a + b            else:                return a - b        else:            return 0""" from z3 import Int, Solver, sat a = Int("a")b = Int("b")  def explore_path(constraints):    """检查给定约束集是否有解, 返回满足条件的样例输入."""    s = Solver()    s.add(*constraints)    if s.check() == sat:        m = s.model()        return m[a].as_long(), m[b].as_long()    return None  def main():    # 程序所有可达路径的约束条件    paths = [        ("a > 0 且 b > 0", [a > 0, b > 0]),        ("a > 0 且 b <= 0", [a > 0, b <= 0]),        ("a <= 0", [a <= 0]),    ]     print("=== 符号执行路径探索演示 ===")    print("目标程序: max_abs(a, b)")    print("  if a > 0:")    print("      if b > 0: return a + b")    print("      else:     return a - b")    print("  else:         return 0")    print()     feasible_count = 0    for name, constraints in paths:        sample = explore_path(constraints)        if sample is not None:            aval, bval = sample            print(f"路径 [{name}] 可行, 样例输入: a={aval}, b={bval}")            feasible_count += 1        else:            print(f"路径 [{name}] 不可行")     print(f"\n程序共有 {len(paths)} 条路径, 其中 {feasible_count} 条可达")  if __name__ == "__main__":    main()
目的：用 Z3 求解器模拟符号执行，对一个三段分支的简单函数穷举所有路径，并为每条可行路径生成样例输入。
  1. from z3 import Int, Solver, sat导入 Z3 求解器的核心组件，相当于给“分身大脑”装好基础能力。
  2. a = Int("a")声明符号变量，此时 a 还不是具体数字，而是可代指任何整数的魔法占位符。
  3. s.add(*constraints)将一条路径的所有约束条件逐条加入求解器，相当于把分身的“路线规则”写进大脑。
  4. if s.check() == sat:调用 Z3 判断这批约束是否可满足，像邮差问“这条路真的存在吗”。
  5. m[a].as_long()从求解器返回的模型中提取符号变量的具体数值，为测试生成真实输入。

常见误区

误区符号执行听起来像一种运行程序的方式，就是把所有输入值都试一遍，找到出错的那个。

正解符号执行不实际运行程序，而是把输入变成符号变量，在数学层面同时探索所有路径。它像邮差在图纸上规划所有路线，而不是真的走一遍；真实奔跑交给测试执行，符号执行负责生成“路线清单”。

为何常见：“执行”二字会让人联想到运行，加上它常被用于找 bug，容易与穷举测试混淆。

误区符号执行能覆盖所有路径，比模糊测试强得多，所以只用符号执行就够了。

正解路径爆炸使符号执行无法穷尽真实程序，速度也远慢于模糊测试。实践中主流方案是两者混合——符号执行深挖边界，模糊测试快速广覆盖，正如分身探路与真身跑街各司其职。

为何常见：符号执行“全路径探索”的口号给人万能错觉，但“理论上能”不等于“工程上可行”。

误区Z3 这类求解器很强大，任何复杂的路径约束丢进去都能立刻给出答案。

正解约束求解的复杂度很高，特别是涉及数组、非线性算术时可能指数级耗时。所以 KLEE 等工具会做缓存、增量求解、约束简化，甚至设置超时来避免卡死——求解器也需要“省着用”。

为何常见：看到演示中求解器瞬间给出结果，就误以为它总是很快，忽略了那些被剪枝或超时的真实场景。

误区KLEE 的文档和示例都是 C 代码，所以它只能分析 C 语言程序。

正解KLEE 工作于 LLVM 字节码层，任何能编译到 LLVM IR 的语言（如 C++、Rust 的某些子集）都有机会接入。它像一位能读懂“通用地图语言”的邮差，不限于某一座城市。

为何常见：大多数教程用 C 演示，让人误以为语言支持仅限 C，实际瓶颈在于字节码转换工具的成熟度。

面试题

Q1. 符号执行中，“符号变量”主要替代什么？

单选题 · easy

  • A.程序中的所有常量值
  • B.程序的具体输入参数← 正确答案
  • C.代码里的变量名称
  • D.函数的所有返回值

答案：B。符号执行的核心是把具体输入值换成符号占位符（如 α 代替 x=5），从而一次探索所有可能的输入。常量、变量名和返回值都不是替代对象，它们只是程序中的静态元素。

Q2. 路径约束（PC）的核心作用是什么？

单选题 · easy

  • A.记录程序的运行耗时
  • B.累积分支条件求可行← 正确答案
  • C.存储磁盘文件数据
  • D.追踪内存地址变化

答案：B。路径约束是走到当前位置所经历的所有分支条件的合取，它决定了哪条路径真实可达。它不记录时间、文件数据，也与内存地址无直接关系。

Q3. KLEE 工具的主要功能是什么？

单选题 · easy

  • A.编译 C 语言源代码
  • B.对程序实施符号执行← 正确答案
  • C.加密程序的二进制
  • D.压缩存储程序文件

答案：B。KLEE 是一个符号执行引擎，它解释执行 LLVM 字节码，并通过约束求解器探索程序路径。编译、加密、压缩都不是它的职责。

Q4. 路径爆炸的本质原因是什么？

单选题 · single

  • A.程序源代码规模过大
  • B.分支数使路径指数激增← 正确答案
  • C.约束求解器执行太慢
  • D.计算机内存容量不足

答案：B。每遇到一个独立分支，路径数就乘 2，k 个分支产生 2^k 条路径。这本质上是分支导致的指数增长，而非代码量大、求解器慢或内存小——内存不足只是爆炸的后果之一。

Q5. 求解器返回 UNSAT 表示什么？

单选题 · single

  • A.该执行路径是可达的
  • B.该执行路径不可行应剪枝← 正确答案
  • C.程序的语法存在错误
  • D.求解器自身发生崩溃

答案：B。UNSAT 意味着不存在任何输入能满足当前路径约束，因此这条路径永远走不到，应当被剪枝。它跟程序语法、求解器崩溃都无关。

Q6. 关于混合测试，下列说法正确的是？

多选题 · mid

  • A.符号执行擅长深挖边界路径← 正确答案
  • B.模糊测试擅长快速广覆盖← 正确答案
  • C.两者结合可提升覆盖率← 正确答案
  • D.两者不能同时用于测试

答案：ABC。符号执行擅长求解深层分支条件，模糊测试擅长快速产生大量随机输入，两者天然互补，结合可显著提升覆盖率。D 显然是错误说法——许多工具正是把两者融合在同一流水线中。

Q7. 下列哪项不是符号执行的挑战？

单选题 · single

  • A.程序路径的数量爆炸
  • B.外部环境交互难建模
  • C.约束求解耗费时间长
  • D.编译器优化级别太低← 正确答案

答案：D。符号执行的挑战集中在路径爆炸、环境交互和约束求解开销。编译器优化级别是工程配置问题，不是符号执行本身固有的挑战。

Q8. 缓解路径爆炸的常用策略有哪些？

单选题 · multiple

  • A.采用启发式搜索策略← 正确答案
  • B.剪除不可满足的路径← 正确答案
  • C.无限延长求解的时间
  • D.与模糊测试相结合← 正确答案

答案：ABD。启发式搜索让探索更有针对性，剪枝删除不可行路径，与模糊测试结合覆盖更多实际区域。无限延长求解时间只会加剧问题，毫无帮助。

Q9. 符号执行的程序状态通常表示为什么？

单选题 · single

  • A.源代码行号和变量值表
  • B.符号存储与路径约束对← 正确答案
  • C.输入数据与输出数据对
  • D.内存地址与机器指令对

答案：B。程序状态用 ⟨符号存储，路径约束⟩ 二元组表示：符号存储保存变量到符号表达式的映射，路径约束记录当前路径的条件。行号、变量值、输入输出对都只是表象，不是完整状态。

Q10. 关于 KLEE 的工作原理，正确的是？

单选题 · multiple

  • A.采用解释执行处理指令← 正确答案
  • B.每次只探索一条路径
  • C.并行维护多个执行状态← 正确答案
  • D.调用求解器判断可行性← 正确答案

答案：ACD。KLEE 解释执行 LLVM 字节码，同时维护一组活跃执行状态（每个状态即一个分身），遇到分支时复制出多个后继状态，并用约束求解器判断每条路径是否可行。它不是单路径探索，而是多状态并行推进。