你抱着一个沉重的大纸箱回到家，里面是一套需要自己组装的衣柜：几十块木板、一袋螺丝、几根金属横杆，还有一本几乎没人认真读的说明书。如果你把所有零件哗啦倒在地上，指望它们自己拼成衣柜，那只能得到一个梦。真正聪明的做法是：翻开说明书，先装底座，再立侧板，然后装抽屉滑轨——每一页图纸都只教你一个小步骤，而且每一步都稳稳踩在刚才完成的那一步上。等所有小步骤做完，一个结实的衣柜就站在你面前了。 这就是 Least-to-Most（从最少到最多）逐步分解提示的核心思想。当我们把一个问题丢给大模型时，如果问题太复杂，模型容易三步错两步。Least-to-Most 的办法是：先让模型把大问题拆成一组由易到难的子问题，然后一个接一个地解决，每解决一个，就把答案递给下一个子问题作为已知信息。它就像那本说明书——把“装衣柜”翻译成十页简单的动作，让模型不再靠瞎猜。 这篇实战指南将带你走完整个流程，从概念原理、拆解策略、提示模板设计、子问题串联，到 few-shot 示例编写、质量评估和失败规避，最后还会聊聊它与思维链（Chain-of-Thought）的搭配使用。

岗位关联

学会 Least-to-Most，等于掌握了一把把复杂推理任务化整为零的钥匙，能让大模型在多跳推理、逻辑计算等场景下稳定输出，这是 Prompt 工程师最值钱的硬技能之一。

目录
  1. 可视化演示
  2. 1 概念原理
  3. 2 分解策略
  4. 3 提示模板
  5. 4 子问题串联
  6. 5 示例设计
  7. 6 质量评估
  8. 7 实战进阶
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示Least-to-Most提示工程三大核心：复杂问题逐步分解为子问题、子问题串联解答传递依赖、以及与直接推理和CoT的效果对比。

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

问题逐步分解流程 将复杂问题Q分解为4个子问题Q1-Q4 逐一解决子问题，最终合成完整答案 Q → {Q1, Q2, Q3, Q4} → Ans 分解降低复杂度，逐步逼近最终答案

1 概念原理

搬回那箱衣柜零件时，你本能地翻开说明书第一页——上面画着成品衣柜，下面写着一行字：“请按以下步骤组装。”你会从这一步开始意识到：完成整件大事，靠的是先看清它由哪些小动作构成。Least-to-Most 也是这个思路：它让模型先“看说明书”，把眼前的大问题翻译成一组小问题。

Least-to-Most Prompting（简称 L2M）是一种提示工程策略，目标场景是那些“一步到位容易翻车”的复杂推理任务，例如多条件逻辑推理、数学应用题、多跳信息检索。它把处理过程分成两个阶段：分解阶段，让模型把原问题拆成一个由易到难的子问题清单；求解阶段，按清单顺序逐个提问，并把前面每个子问题的答案作为后面子问题的已知信息带上。

这里的“逐个提问”不是一句话里塞多个问题，而是每次向模型单独发一个子问题，所以它天然比思维链（Chain-of-Thought, CoT）多出若干轮交互。CoT 是在一次输出中让模型“边想边说”，L2M 则把整个推理过程拆成可见、可控的多轮对话。这样做的优势是：每一步都可以被检查、被修正，错误不容易悄悄滑过。

就像说明书绝不会要求你一口气把柜子装完，L2M 也从不奢望模型一口气答对。它把“装柜子”翻译成十几页干净利落的动作，每页只解决一个问题，答案就稳稳地一层层垒上去。

P={p1,p2,…,pn},ai=f(pi∣a1,…,ai−1)\displaystyle P = \{p_1, p_2, \ldots, p_n\}, \qquad a_i = f(p_i \mid a_1, \ldots, a_{i-1})
这个公式描述 L2M 的两件核心事：把原问题拆成 n 个子问题的集合，以及第 i 个子问题的答案依赖前面所有答案。
  1. 问题集合$P$ 表示原复杂问题被分解出的子问题集合，花括号 $\{ \}$ 列举出全部元素 $p_1$ 到 $p_n$。
    P={p1,p2,…,pn}P = \{p_1, p_2, \ldots, p_n\}
  2. 子问题下标$p_i$ 表示第 $i$ 个子问题，下标 $i$ 刻画了它在求解顺序中的位置，越小越先解决。
    pip_i
  3. 求解函数$a_i$ 是第 $i$ 个子问题的答案，$f(\cdot)$ 表示大模型针对这一个子问题的一次推理求解。
    ai=f(pi∣a1,…,ai−1)a_i = f(p_i \mid a_1, \ldots, a_{i-1})
  4. 历史依赖竖线后的 $a_1, \ldots, a_{i-1}$ 表示前面所有答案都会作为本次求解的上下文输入。
    a1,…,ai−1a_1, \ldots, a_{i-1}

2 分解策略

装衣柜时，底座没调平，上面的隔板就全是歪的；抽屉导轨的方向装反，后面无论如何都推不进去。说明书所以不能随便打乱页序，是因为“先装什么、后装什么”背后有一套硬逻辑。L2M 的分解策略，就是帮你找到这套硬逻辑。

好的分解遵循三条原则。其一，由易到难：把简单子问题放在前面，让模型先积累“已答对”的信心与上下文，再用这些上下文去攻难点。其二，依赖驱动：如果子问题 B 的计算需要 A 的结果，那 A 必须排在 B 前面，顺序即依赖图。其三，粒度适宜：每个子问题本身应该是“一句能说清、一步能解决”的完整小任务——大到还需要再拆就超标，小到只剩一个动作就失去意义。

实际任务可以按类型拆分：算术题按计算次序拆，每一步的结果都是下一步的输入；逻辑推理按条件链拆，把前提和结论逐个配对；长文写作按章节层次拆，先定提纲再逐段展开。这就是“任务分型”——先判断问题属于哪种结构，再选择对应的切法。

说明书从底座画到顶板，每一页都不多余、不遗漏，L2M 的分解也要做到“少一页装不成、多一页看不懂”。拆得刚刚好，后面每一步才有意义。

x≈p1⊕p2⊕⋯⊕pn,⋃i=1nCov(pi)⊇Cov(x)\displaystyle x \approx p_1 \oplus p_2 \oplus \cdots \oplus p_n, \qquad \bigcup_{i=1}^{n} \text{Cov}(p_i) \supseteq \text{Cov}(x)
该公式说明：按顺序拼接的子问题要能覆盖原问题的全部知识要点，不遗漏、不颠倒。
  1. 拼接符号$\oplus$ 表示把子问题按顺序拼接起来，整体应还原出原问题 $x$ 的轮廓。
    x≈p1⊕p2⊕⋯⊕pnx \approx p_1 \oplus p_2 \oplus \cdots \oplus p_n
  2. 覆盖函数$\text{Cov}(\cdot)$ 表示某问题涉及的知识要点集合，是评估分解是否完整的标尺。
    Cov(x)\text{Cov}(x)
  3. 并集覆盖$\bigcup_{i=1}^{n}$ 是集合并运算，含义是所有子问题覆盖范围的并集必须包含（$\supseteq$）原问题的覆盖范围。
    ⋃i=1nCov(pi)⊇Cov(x)\bigcup_{i=1}^{n} \text{Cov}(p_i) \supseteq \text{Cov}(x)

3 提示模板

说明书的版式永远是固定的：顶部是成品图，中间是零件清单，底部是分步图解。你要找“导轨怎么装”，直接翻到对应页就行。L2M 也一样，模板就是你的说明书版式——固定结构，反复复用。

在工程实现中，L2M 至少需要两个模板。分解模板负责执行第一阶段：它告诉模型“这是原问题，请按由易到难的顺序输出 n 个子问题，每行一个，不要写解答”。求解模板负责执行第二阶段：它把原问题、当前子问题、以及前面所有子问题的答案拼在一起，让模型在完整上下文中作答。两个模板通常是函数，输入参数不同，输出的 prompt 结构一致。

模板设计的细节决定成败：各部分之间要用清晰的角色标签分隔，例如 [原问题]、[历史答案]、[当前子问题]；子问题编号要保留，方便模型追踪进度；历史答案要按顺序排列，让模型一眼看到“已经做到哪一步”。这些标签就像说明书里的图标，减少模型的歧义。

模板是那张反复使用的说明书页。只要版式定得好，换什么问题都能往上套——这就是“提示结构化”的工程价值。

Prompt(pi)=[原问题]  x  ⊕  [历史答案]  a<i  ⊕  [当前子问题]  pi\displaystyle \text{Prompt}(p_i) = [\text{原问题}]\; x \; \oplus \; [\text{历史答案}]\; a_{<i} \; \oplus \; [\text{当前子问题}]\; p_i
这个公式展示求解模板的拼接结构：三个带标签的字段按固定顺序拼成一个完整提示。
  1. 字段标签$[\text{原问题}]$、$[\text{历史答案}]$、$[\text{当前子问题}]$ 是模板中固定出现的标签，告诉模型每段信息的角色。
    [原问题],  [历史答案],  [当前子问题][\text{原问题}],\; [\text{历史答案}],\; [\text{当前子问题}]
  2. 拼接顺序$\oplus$ 依次拼接三段，顺序即模型读取信息的顺序，先回顾全局、再看历史、最后聚焦当前。
    x  ⊕  a<i  ⊕  pix \; \oplus \; a_{<i} \; \oplus \; p_i
  3. 历史答案简写$a_{<i}$ 表示 $a_1$ 到 $a_{i-1}$ 的全部答案集合，是“已经装好的下层柜体”。
    a<i={a1,a2,…,ai−1}a_{<i} = \{a_1, a_2, \ldots, a_{i-1}\}

4 子问题串联

你装完底座，把侧板立起来时，侧板底部的定位孔要正好卡进底座上凸起的木榫。没有这个榫卯，下一块板就无处生根。L2M 里，前一个子问题的答案就是那根木榫。

子问题串联的实质是：把上一轮模型的输出，变成下一轮模型的输入。具体做法是维护一个“已解决列表”，里面按顺序存放 子问题 -> 答案 条目。在构造第 i 个子问题的求解 prompt 时，把这个列表格式化进 [历史答案] 字段。模型读到的就不是一个孤立的新问题，而是一个“已经走了几步、还差几步”的完整路线图。

工程上要注意上下文管理：如果历史答案太多，可以只携带与当前子问题最相关的几条，而不是全量塞入；每条答案要控制长度，比如强制模型用一句话总结结果。这样既保证依赖信息不丢，又避免上下文无限膨胀导致成本上升、注意力被稀释。

每一颗螺丝都拧进上一块板预留的孔里，柜子才能越装越高。L2M 的“答案接力”，就是靠这种朴素的榫卯结构把分散的步骤连成整体。

ai=arg⁡max⁡a  Pθ(a∣pi,  a<i)\displaystyle a_i = \underset{a}{\arg\max} \; P_\theta(a \mid p_i, \; a_{<i})
该公式表示：模型生成第 i 个答案时，会把当前子问题和历史答案同时作为条件，输出概率最高的答案序列。
  1. 生成概率$P_\theta(a \mid \cdot)$ 指在模型参数 $\theta$ 下，生成答案 $a$ 的概率分布。
    Pθ(a∣pi,a<i)P_\theta(a \mid p_i, a_{<i})
  2. 条件上下文$p_i$ 与 $a_{<i}$ 共同作为条件，说明生成不仅依赖当前子问题，还依赖全部历史答案。
    pi,  a<ip_i, \; a_{<i}
  3. 取最大$\arg\max$ 表示模型选择概率最高的答案序列作为最终输出，这也是自回归模型的标准解码方式。
    arg⁡max⁡a  Pθ(a∣pi,a<i)\underset{a}{\arg\max} \; P_\theta(a \mid p_i, a_{<i})

5 示例设计

说明书里最受欢迎的永远是示意图：画着一只手如何把导轨卡进侧板凹槽。文字写得再细，也不如一张“看，就是这样”的图来得快。对模型而言，few-shot 示例就是那张示意图。

在 L2M 中，示例的典型结构是一个三元组：原题 $q_j$、拆解清单 $r_j$、逐步求解结果 $s_j$。给模型两个这样的完整示例，再抛出真正的测试题，它就能模仿出“先拆后解”的格式。示例不是随便选的：第一个示例用最简单的问题，示范“怎么拆”；第二个示例稍微复杂一点点，示范“答案怎么传”；两个示例之间要有一个明显的难度台阶。

示例编排还有两个进阶技巧。一是正反结合：给一个好示例和一个坏示例，并简单说明坏示例错在哪，模型对“边界”的感知会更强。二是保持风格一致：示例里子问题的编号方式、答案的字数、标签的写法，都必须和正式模板完全一致，否则模型会学到混乱的格式。

图纸上的那只手教的是“标准动作”，few-shot 示例教的是“标准格式”。模型照着示例有样学样，比只靠一句“请分解”可靠得多。

Dk={(qj,  rj,  sj)}j=1k\displaystyle D_k = \{(q_j,\; r_j,\; s_j)\}_{j=1}^{k}
该公式表示：few-shot 演示集包含 k 个三元组示例，每个示例同时展示原题、拆解和答案，供模型模仿。
  1. 示例集合$D_k$ 是包含 $k$ 个示例的演示集，$k$ 通常取 2 到 5 个。
    DkD_k
  2. 三元组结构$q_j$ 为第 $j$ 个示例的原题，$r_j$ 为该题的拆解清单，$s_j$ 为最终答案，三者共同构成一个完整示范。
    (qj,  rj,  sj)(q_j,\; r_j,\; s_j)
  3. 下标范围$j=1$ 到 $k$ 表示逐个列举所有示例，顺序即模型看到的顺序。
    j=1,2,…,kj = 1, 2, \ldots, k

6 质量评估

柜子装完，你不能只看它立着就宣布胜利——得推一推，看它晃不晃；拉开抽屉，看顺不顺滑；低头看看，有没有零件多出来。L2M 的质量评估也是这么较真，它分两层：分解质量和最终效果。

分解质量看三件事：覆盖度，所有子问题是否覆盖原题的全部关键条件和约束，有没有漏项；顺序，子问题是否严格按依赖关系排列，有没有“答案还没出来就用到它”的倒挂；粒度，每个子问题是否足够独立，能否单独验证。这三项可以人工抽检，也可以让另一个模型打分。最终效果则看整体任务的完成情况，最常用的是准确率，也可以根据业务自定义指标，比如客服场景的“一次性解决率”。

工程上建议把评估做成固定流程：先在验证集上跑一遍 L2M，记录每个子问题的输出；然后对比分解清单与人工标注的黄金清单，计算覆盖度；最后把失败的样本收集起来，看错误发生在第几步。这样诊断出的问题，往往能直接反哺模板和示例的修改。

装完柜子推一推、压一压，才知道哪里松了。L2M 评估的价值不是给个分数，而是让每一步装得结不结实都看得见。

Acc=1n∑i=1nI(a^i=ai∗)\displaystyle \text{Acc} = \frac{1}{n} \sum_{i=1}^{n} \mathbb{I}(\hat{a}_i = a_i^{*})
该公式是最终效果评估的通用准确率公式：所有样本中预测答案与标准答案一致的比例。
  1. 指示函数$\mathbb{I}(\cdot)$ 是示性函数，括号内条件成立取 1，不成立取 0。
    I(a^i=ai∗)\mathbb{I}(\hat{a}_i = a_i^{*})
  2. 预测与标准$\hat{a}_i$ 是模型输出的答案，$a_i^{*}$ 是人工标注的标准答案。
    a^i,  ai∗\hat{a}_i, \; a_i^{*}
  3. 求平均$\frac{1}{n} \sum_{i=1}^{n}$ 对所有样本的命中情况求平均，得到总体准确率。
    Acc=1n∑i=1nI(a^i=ai∗)\text{Acc} = \frac{1}{n} \sum_{i=1}^{n} \mathbb{I}(\hat{a}_i = a_i^{*})

7 实战进阶

老师傅装柜子有个习惯：先站远一点看总图，记住整体结构，然后蹲下来按步骤拧螺丝；遇到拧不进去的，不硬来，换把螺丝刀再试。这就是实战进阶的三个关键词：总图、工具、迭代。

第一个关键词是“与 CoT 协同”。L2M 负责对外串联子问题，CoT 负责对内加深推理。具体做法是：在求解模板里加上一句“请先逐步推理再给出结论”，让模型在每个子问题内部把思考过程写出来。这样既保留 L2M 的显式分解和答案传递，又获得 CoT 的单步推理增强，两者的优势可以叠加。

第二个关键词是“失败规避”。常见失败模式包括：分解遗漏关键条件导致答案跑偏；过度分解导致上下文过长、错误逐级放大；子问题答案格式不统一导致后续拼接混乱。应对手段有：限制子问题数量上限、设置最大迭代轮数、在模板中强制“每步答案一句话总结”、对中间输出做格式校验。

第三个关键词是“迭代优化”。拿真实业务数据反复跑评估流程，把失败样本分类，哪类错误多就针对性改进：模板标签不清晰就换措辞，示例风格不一致就重写示例，粒度不合适就调整分解指令。每一次迭代都像换一把更合适的螺丝刀，让 L2M 在你的场景里越用越顺。

老师傅总图在手、工具在腰、经验在脑。L2M 实战也一样：分解是总图，模板和示例是工具，评估迭代是经验。三者齐备，再复杂的问题也能拆得开、装得稳。

ai=CoTθ(pi,  a<i)=arg⁡max⁡a  Pθ(a∣pi,  a<i,  "逐步推理")\displaystyle a_i = \text{CoT}_\theta(p_i,\; a_{<i}) = \underset{a}{\arg\max} \; P_\theta(a \mid p_i,\; a_{<i},\; \text{"逐步推理"})
该公式表示：在 L2M 的串联框架内部，用 CoT 触发词让模型完成单步推理，再输出答案。
  1. 内部思维链$\text{CoT}_\theta$ 表示在子问题内部引入思维链推理，模型先生成中间步骤再给结论。
    CoTθ(pi,a<i)\text{CoT}_\theta(p_i, a_{<i})
  2. 外部串联保留$a_{<i}$ 依然作为历史答案传入，说明 L2M 的多轮依赖结构没有被破坏。
    a<ia_{<i}
  3. 触发词提示字符串“逐步推理”引导模型输出推理过程，最终答案 $a_i$ 由这个过程推导而来。
    Pθ(a∣pi,a<i,"逐步推理")P_\theta(a \mid p_i, a_{<i}, \text{"逐步推理"})

AI 应用场景

智能客服故障排查

阶段：Prompt 推理增强阶段

解决的问题：传统客服机器人面对“我的柜子装完抽屉推不进去”这类复合问题，只能匹配关键词，答非所问。用 L2M 模板先分解出“检查抽屉导轨是否装反、检查是否卡住杂物、检查螺丝是否过长”等子问题，再逐个子问题追问用户确认，就能精准定位故障。

具体案例：某家具电商的售后客服接入 L2M 后，用户描述问题时，系统先让模型拆出 3-5 个排查子问题，每问一步收集一个答案，最后综合给出处理方案。数据显示，一次解决率从 41% 提升到 68%。

自然语言转 SQL 查询

阶段：数据查询生成阶段

解决的问题：业务人员用大白话问“上个月华东区销量最高的前五款产品分别卖了多少，退货率又是多少”，直接让模型生成 SQL 极易漏掉多表关联条件。L2M 先把问题拆成“定位时间范围、定位区域、排序取前五、关联退货表”等子查询，再按顺序拼接成完整 SQL。

具体案例：某零售数据分析平台把 L2M 模板嵌入 BI 工具的问答入口，模型先生成子问题清单让用户确认，再逐步生成各段 SQL。复杂查询的生成准确率从 52% 提升到 79%，业务方也能看懂中间每一步在算什么。

长文档报告自动生成

阶段：内容生成组织阶段

解决的问题：让模型直接写一份五千字的行业分析报告，开头能看、结尾跑题是家常便饭。L2M 把写作任务分解成“先写摘要框架、再逐章展开、最后总结结论”，每一章都携带前面章节的要点，保证全文逻辑连贯。

具体案例：某咨询公司的分析师用 L2M 模板生成市场周报。分解模板先产出三级提纲，求解模板按“摘要 -> 市场动态 -> 竞品分析 -> 趋势预测 -> 结论建议”逐章生成，每章开头附上上一章结论。报告返工率降低了约一半。

Python 演示

python57 行
"""Least-to-Most 逐步分解: 把复杂问题拆成子问题并逐个求解。""" DECOMPOSE_TEMPLATE = (    "你需要解决以下问题:\n{problem}\n"    "请先把它分解成 {n} 个由易到难的子问题,\n"    "每行一个, 不要写解答。") SOLVE_TEMPLATE = (    "原问题: {problem}\n"    "当前子问题: {sub_problem}\n"    "已知前面子问题的答案:\n{context}\n"    "请先参考已知信息, 再解决当前子问题。")  class LeastToMostSolver:    """最小到最多求解器: 分解 -> 串联求解。"""     def __init__(self, llm_call, n_sub=3):        self.llm_call = llm_call        self.n_sub = n_sub        self.solved_map = {}     def decompose(self, problem):        prompt = DECOMPOSE_TEMPLATE.format(problem=problem, n=self.n_sub)        text = self.llm_call(prompt)        return [line.strip() for line in text.splitlines() if line.strip()]     def build_context(self):        return "\n".join(            "{0} -> {1}".format(sub, ans)            for sub, ans in self.solved_map.items()        )     def solve(self, problem):        sub_list = self.decompose(problem)        for sub in sub_list:            context = self.build_context()            prompt = SOLVE_TEMPLATE.format(                problem=problem, sub_problem=sub, context=context            )            self.solved_map[sub] = self.llm_call(prompt)        return self.solved_map[sub_list[-1]]  def fake_llm(prompt):    """演示用大模型: 识别关键字后返回固定答案。"""    if "分解" in prompt:        return "核对订单状态\n计算应付金额\n生成确认消息"    return "已处理(演示答案)"  if __name__ == "__main__":    solver = LeastToMostSolver(fake_llm)    final_answer = solver.solve("用户下单后需要确认订单并告知总价")    print("最终答案:", final_answer)
目的：实现一个最小可运行的 Least-to-Most 求解框架，演示“先分解、再逐步串联求解”的完整流程，替换 fake_llm 即可接入真实大模型 API。
  1. class LeastToMostSolver定义求解器类，封装分解与串联求解的全部逻辑。
  2. self.solved_map = {}用字典保存每个子问题的答案，是答案传递的核心存储。
  3. def decompose(self, problem)调用分解模板，把返回文本按行拆成子问题列表。
  4. def build_context(self)把已解决的子问题和答案格式化成上下文文本。
  5. for sub in sub_list:逐个求解子问题，保证后一个一定看到前一个的答案。
  6. self.solved_map[sub] = self.llm_call(prompt)将当前子问题答案存入字典，供后续拼接。
  7. return self.solved_map[sub_list[-1]]最终答案取最后一个子问题的求解结果。
  8. if "分解" in prompt:演示用的模型分支：识别到分解指令就返回拆解清单。
  9. if __name__ == "__main__":程序入口，一键跑通整个 L2M 流程。

常见误区

误区把问题拆成很多很多小步骤，模型肯定能答对，拆得越碎越稳。

正解拆得太碎会让上下文越来越长、调用次数直线上升，而且任何一步出错都会像多米诺骨牌一样向后传播。好的分解讲究“粒度适中”：每个子问题本身能独立说清一件事，又适合承载前面的上下文。就像说明书如果一页只画“拿起一颗螺丝”，你反而不知道螺丝该拧在哪。

为何常见：L2M 的直觉是“分解降低难度”，新手容易把“多步骤”误当成“碎步骤”，忽略了步骤之间的依赖成本。

误区思维链不也是让模型一步步想吗？Least-to-Most 只是换了个名字。

正解CoT 是在一次输出中让模型生成整个推理过程，整条链在同一轮对话里完成；L2M 是显式多轮：先分解，再逐个子问题调用模型，每轮把上一轮答案拼进下一轮输入。两者容错方式不同，一个是“一口气装完再总结”，一个是“每装一层拍照再装下一层”。

为何常见：两者都展示“步骤化”外观，小白容易只看到表面的“多步”，而忽略了多轮交互与答案传递的本质差异。

误区既然已经拆开了，就可以把几十个子问题一次性并行发给模型，反正互不影响。

正解L2M 的关键正在于子问题之间存在依赖：后一个问题的求解需要前一个问题的答案。若把它们当成独立任务并行处理，模型会丢失关键上下文，等于把说明书每一页撕下来同时看，反而装不成柜子。只有在确认某个子问题完全不依赖其他步骤时，才能单独并行。

为何常见：并行是工程上最自然的性能优化冲动，但容易忽略 L2M 设计里“答案串联”这条主线。

误区在提示词里加一句“请一步一步思考”，不就实现 Least-to-Most 了吗？

正解这句话只是触发 CoT 的常用指令，它不要求模型先输出分解清单，也没有把每个子问题作为独立轮次求解，答案之间没有强制传递。L2M 需要两个动作缺一不可：显式分解 + 逐个子问题求解并携带历史答案。光喊口号没有流程，柜子照样散架。

为何常见：“逐步思考”是流传最广的提示技巧之一，很多人以为所有分步方法共享同一条咒语，忽略了流程结构的差异。

误区结果对了就说明分解没问题；结果错了就是模型太笨，跟我设计的提示没关系。

正解最终答案对，也可能掩盖分解质量差的风险；最终答案错，问题可能出在分解遗漏条件、顺序颠倒、上下文没传全。应该单独评估中间产物：子问题是否覆盖原题关键要素、是否按依赖排序、历史答案是否被正确引用。好比柜子虽然立住了，但侧板装反了，早晚会倒。

为何常见：人本能地只关注结果指标，容易跳过过程质量体检，而 L2M 的优势恰恰在于中间过程完全可见可查。

面试题

Q1. Least-to-Most 提示的核心理念是什么？

单选题 · easy

  • A.把复杂问题拆成小问题逐个解← 正确答案
  • B.用更大的模型一次算到底
  • C.随机抽样多个答案再投票
  • D.只给模型一个奖励函数

答案：A。L2M 的核心是把复杂问题显式分解成由易到难的子问题清单，然后逐个求解，A 准确描述了这一理念。B 是加大模型规模，C 是自洽性采样，D 是强化学习思路，都与提示分解无关。

Q2. 与思维链 CoT 相比，L2M 最大的区别是什么？

单选题 · mid

  • A.它在一次输出中隐含分步
  • B.它是显式分步并逐轮求解← 正确答案
  • C.它完全不使用任何示例提示
  • D.它只适合图片类视觉任务

答案：B。CoT 在一次输出中让模型隐式写出推理步骤，L2M 则显式分成多轮：先拆解，再每个子问题单独调用一次模型，并把前一步答案传给下一步，B 正确。A 描述的正是 CoT。C、D 都是对 L2M 的误解。

Q3. L2M 中，子问题之间的正确关系是什么？

单选题 · easy

  • A.完全独立可以并行处理
  • B.后一步依赖前一步结果← 正确答案
  • C.仅共享同一提示模板
  • D.随机顺序无任何依赖

答案：B。L2M 的子问题通过“前步答案带入下一步”实现串联，后一个子问题的求解依赖前面所有答案，B 正确。若完全独立，就没有必要多轮传递，A、C、D 都违背了 L2M 的设计初衷。

Q4. 下面哪一项不属于好的分解原则？

单选题 · mid

  • A.由易到难逐步递进
  • B.每步只解决单一任务
  • C.前后步骤保持依赖关系
  • D.步骤越碎越细就越好← 正确答案

答案：D。好的分解讲究“粒度适中”，每步是完整的小任务；拆得过碎会导致上下文膨胀和错误累积，D 是典型误区。A 是排序原则，B 是粒度原则，C 是依赖原则，都是 L2M 分解的正确要求。

Q5. 标准 L2M 流程中，模型需要被调用几次？

单选题 · mid

  • A.一次调用内分多个输出段
  • B.多次调用逐个子问题求解← 正确答案
  • C.每次调用只输出答案汇总
  • D.一般需要人类全程干预

答案：B。标准 L2M 是两次以上调用：先一次调用完成分解，再对每个子问题各调用一次求解，B 正确。A 是 CoT 的做法，C 与逐步求解矛盾，D 把 L2M 误解为半自动流程。

Q6. 在求解模板中，历史答案通常以什么形式放入？

单选题 · mid

  • A.随机打乱的无序列表
  • B.按顺序排列的已知信息← 正确答案
  • C.只放最新一个答案
  • D.放在当前子问题之后

答案：B。历史答案应按求解顺序排列成“已知信息”列表，让模型清楚已做到哪一步，B 正确。打乱顺序会破坏依赖关系，只放最新答案会丢失更早上下文，把历史放当前问题之后也违背模板的“先回顾再聚焦”结构。

Q7. 过度分解可能导致哪些后果？

单选题 · hard

  • A.子问题边界变模糊，错误一层层累积
  • B.模型上下文变长，错误传播概率增加
  • C.需要更多调用次数，成本与延迟上升
  • D.以上都是过度分解的典型风险← 正确答案

答案：D。过度分解会让子问题丧失独立性，前一步错误沿链条放大；上下文随子问题数量膨胀；每次调用都有成本。A、B、C 分别命中质量、效率、成本三个维度，因此选 D。

Q8. 下面哪一项是典型的错误传播场景？

单选题 · hard

  • A.第一个子问题答错，后续全部跑偏← 正确答案
  • B.最后一步答案正确但格式不符合
  • C.示例数量太多导致上下文超出限制
  • D.模型无法识别问题的学科类型

答案：A。L2M 是串行结构，第一个子问题的答案会作为后续所有问题的上下文，一旦出错，后续推理会沿着错误前提继续，A 是错误传播的典型表现。B、C 是格式与工程问题，D 是任务分类问题，均不属于依赖链上的错误传播。

Q9. 在 L2M 中，few-shot 示例应该包含哪些内容？

多选题 · mid

  • A.原题与分解出的子问题清单← 正确答案
  • B.每个子问题的求解答案← 正确答案
  • C.子问题答案如何串联传递← 正确答案
  • D.模型的训练参数设置

答案：ABC。L2M 示例三元组由原题、拆解清单、求解答案构成，A 和 B 是基础内容；示例还要展示答案如何逐步传递，所以 C 也应包含。D 是训练配置，与提示阶段无关。

Q10. 评估 L2M 分解质量时，需要关注哪些维度？

多选题 · hard

  • A.子问题覆盖全部关键条件← 正确答案
  • B.子问题顺序符合依赖逻辑← 正确答案
  • C.每个子问题单一且可验证← 正确答案
  • D.模型输出的推理链最短

答案：ABC。分解质量看覆盖度、顺序、粒度三个维度：A 对应覆盖度，B 对应顺序，C 对应粒度，三者缺一不可。D 不是评估目标，推理链是否短与分解质量无关，反而过短的推理可能意味着跳过必要步骤。

Q11. 下列哪些场景最适合使用 L2M 提示策略？

多选题 · extreme

  • A.多条件约束的组合规划任务← 正确答案
  • B.需要多步计算逐层传值← 正确答案
  • C.单步分类的垃圾邮件识别
  • D.长文档多实体关系推理← 正确答案

答案：ABD。L2M 适合“可以分解且子问题存在依赖”的复杂任务，组合规划、多步计算、多实体关系推理都在其射程内，A、B、D 正确。单步分类本身足够简单，分解反而增加开销，C 不适合。