返回专栏
· 23 分钟阅读

Planning 与任务分解


一、什么是 Planning?

Planning(规划)是 Agent 在执行任务之前或执行过程中,根据目标、约束、当前状态和可用工具,构建并持续调整执行方案的过程。

它解决的核心问题不是简单地回答用户,而是确定:

  • 做什么:明确最终目标与需要完成的子目标。
  • 怎么做:确定执行步骤、工具和处理策略。
  • 先做什么:分析任务之间的依赖关系。
  • 如何判断完成:定义每个子任务和整体任务的完成条件。
  • 失败怎么办:设计重试、替代方案、补偿和重新规划机制。
  • 何时停止:判断目标是否达成,避免无限执行。

例如,用户提出:

分析最近三个月的销售数据,找出业绩下降的主要原因,并生成一份分析报告。

这不是一个简单的单步任务,而是包含数据获取、数据清洗、统计分析、原因识别、报告生成等多个环节的复合任务。

Agent 需要先理解目标,再拆解任务,确定依赖关系,选择工具,最后逐步执行和验证。

1. Planning 与相关概念的区别

概念 核心职责 关注重点
Reasoning 推理与判断 为什么这样做
Planning 制定执行方案 接下来做什么
Task Decomposition 任务分解 将目标拆成哪些子任务
Execution 执行任务 如何完成具体操作
Workflow 工作流编排 步骤如何按照规则运行
Evaluation 结果评估 执行结果是否符合要求

这些能力相互配合,但不能混为一谈。

Reasoning 可以帮助 Agent 判断某个任务应该如何处理;Planning 将判断结果组织成执行计划;Task Decomposition 将复杂目标细化为可执行单元;Execution 负责真正执行;Evaluation 判断执行结果是否满足要求。

二、为什么需要任务分解?

大模型虽然具备复杂推理能力,但直接执行复杂目标仍然存在明显问题:

  1. 上下文复杂:一个目标可能涉及大量信息、约束和业务规则。
  2. 执行步骤多:复杂任务通常包含多个相互依赖的操作。
  3. 工具调用不确定:外部工具可能超时、失败或返回异常数据。
  4. 结果难以验证:整体目标可能没有明确的单一判断标准。
  5. 错误传播:前置步骤出现错误,可能导致后续所有步骤失效。
  6. 执行成本高:不合理的步骤安排会造成重复调用和资源浪费。

任务分解的价值在于降低单个执行单元的复杂度,让 Agent 能够独立执行、检查和恢复每个子任务。

1. 整体目标与子任务

以销售数据分析为例:

整体目标:

生成最近三个月的销售分析报告,识别业绩下降原因。

分解后的子任务:

编号 子任务 输出
T1 确认分析时间范围和指标定义 分析口径
T2 获取销售数据 原始数据集
T3 检查数据完整性和质量 数据质量报告
T4 清洗和转换数据 标准化数据集
T5 计算销售趋势和关键指标 统计结果
T6 分析区域、产品和渠道表现 维度分析结果
T7 识别业绩下降的主要因素 原因分析
T8 生成分析报告 最终报告

其中,T3 依赖 T2,T4 依赖 T3,T5 和 T6 依赖 T4,T7 依赖 T5 和 T6,T8 依赖 T7。

任务分解并不只是把一句话拆成多个句子,而是要形成可以执行、可以验证、可以追踪的任务结构。

三、任务分解的核心原则

1. 目标明确

每个子任务都应该有明确的目标,避免出现模糊描述。

不合理的任务:

  • 分析数据。
  • 处理结果。
  • 优化报告。

这些任务没有说明具体操作和预期结果,无法判断是否完成。

更合理的任务:

  • 按月份统计销售额、订单数和客单价。
  • 计算每个区域的销售额同比和环比变化。
  • 找出销售额下降幅度最大的三个产品类别。
  • 根据统计结果生成包含结论和数据依据的分析报告。

2. 输入和输出明确

每个任务都应该定义输入和输出。

例如:

{
  "task_id": "T5",
  "name": "计算销售趋势",
  "description": "按月份计算销售额、订单数和客单价",
  "inputs": {
    "dataset": "cleaned_sales_data",
    "time_range": "last_3_months"
  },
  "outputs": {
    "monthly_metrics": "MonthlyMetrics"
  },
  "status": "pending"
}

输入定义任务需要什么数据,输出定义任务完成后应该产生什么结果。

明确的输入输出契约可以减少子任务之间的歧义,也有利于任务重试、并行执行和结果验证。

3. 依赖关系明确

任务之间通常存在依赖关系。

例如:

  • 数据分析依赖数据获取。
  • 报告生成依赖分析结果。
  • 发布报告依赖报告审核。

如果没有正确识别依赖关系,Agent 可能在必要数据尚未产生时就执行后续任务。

4. 粒度适中

任务拆得太粗,执行过程难以控制;拆得太细,则会产生大量任务调度和上下文管理开销。

例如:

拆分过粗:

T1:完成销售分析并生成报告

无法独立控制数据获取、统计分析和报告生成。

拆分过细:

T1:读取文件
T2:读取第一列
T3:读取第二列
T4:读取第三列
T5:计算第一行
T6:计算第二行

任务数量过多,增加调度成本。

合理拆分:

T1:获取销售数据
T2:清洗数据
T3:计算关键指标
T4:分析业务维度
T5:归纳下降原因
T6:生成报告

合理的粒度应当以独立执行、明确验收和可恢复为主要判断标准。

5. 完成条件明确

任务不能只定义执行动作,还需要定义完成标准。

例如:

{
  "task_id": "T3",
  "name": "数据质量检查",
  "completion_criteria": [
    "关键字段不存在空值",
    "日期格式符合要求",
    "销售金额均为有效数值",
    "重复订单已经识别"
  ]
}

没有完成条件,Agent 就可能将工具调用成功误认为任务成功。

四、任务分解的常见方法

不同任务具有不同结构,Agent 可以采用不同的分解策略。

1. 顺序分解(Sequential Decomposition)

将复杂任务拆成具有严格先后顺序的子任务。

适用于:

  • 数据处理流水线。
  • 文档处理。
  • 代码编译与测试。
  • 需要逐步验证的业务流程。
flowchart TD
    A["接收整体目标"] --> B["任务 T1:获取数据"]
    B --> C["任务 T2:清洗数据"]
    C --> D["任务 T3:分析数据"]
    D --> E["任务 T4:生成报告"]
    E --> F["验证最终结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

顺序分解的优点是结构简单、执行过程容易追踪;缺点是无法充分利用任务之间的并行机会。

2. 并行分解(Parallel Decomposition)

当多个子任务之间不存在直接依赖关系时,可以同时执行。

例如,分析销售数据时,可以同时统计不同区域、产品类别和销售渠道的表现。

flowchart TD
    A["获取并清洗销售数据"] --> B["区域销售分析"]
    A --> C["产品销售分析"]
    A --> D["渠道销售分析"]
    B --> E["汇总分析结果"]
    C --> E
    D --> E
    E --> F["生成综合结论"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

并行执行需要关注:

  • 任务是否真正独立。
  • 是否存在共享资源竞争。
  • 是否需要对结果进行聚合。
  • 并发数量是否超过系统限制。
  • 某个任务失败是否影响其他任务。

并行不代表所有任务都可以同时执行。只有在输入数据已经就绪、任务之间不存在未解决依赖时,才适合并行调度。

3. 层级分解(Hierarchical Decomposition)

将复杂目标拆成多个子目标,再进一步将子目标拆成具体任务。

例如:

销售分析
├── 数据准备
│   ├── 获取销售数据
│   ├── 检查数据质量
│   └── 清洗数据
├── 业务分析
│   ├── 时间趋势分析
│   ├── 区域分析
│   └── 产品分析
└── 报告生成
    ├── 汇总分析结果
    ├── 提炼核心结论
    └── 生成报告

层级分解适用于目标范围较大、包含多个业务模块的复杂任务。

它能够控制规划复杂度,也方便不同 Agent 或子规划器负责不同领域。

需要注意,层级结构不一定意味着执行顺序。一个层级下的多个任务仍然可能存在依赖关系,也可能并行执行。

4. 条件分解(Conditional Decomposition)

根据执行结果决定后续任务。

例如,数据质量检查通过后继续分析;未通过时先进行数据修复。

flowchart TD
    A["获取销售数据"] --> B["检查数据质量"]
    B --> C{"数据质量是否合格"}
    C -->|"是"| D["执行销售分析"]
    C -->|"否"| E["执行数据修复"]
    E --> F{"修复是否成功"}
    F -->|"是"| D
    F -->|"否"| G["记录失败并请求人工处理"]
    D --> H["生成分析报告"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

条件分解的关键是将判断逻辑显式化,避免 Agent 在执行过程中随意改变任务路径。

5. 迭代分解(Iterative Decomposition)

有些任务无法一次性确定完整计划,需要根据中间结果不断细化。

例如,用户要求分析某个系统的性能瓶颈。Agent 可能先进行整体性能分析,再根据发现的热点深入分析数据库、网络或 CPU。

flowchart TD
    A["接收复杂目标"] --> B["生成初始任务计划"]
    B --> C["执行当前任务"]
    C --> D["评估中间结果"]
    D --> E{"是否发现需要深入处理的问题"}
    E -->|"是"| F["生成新的子任务"]
    F --> G["更新任务计划"]
    G --> C
    E -->|"否"| H{"整体目标是否完成"}
    H -->|"否"| B
    H -->|"是"| I["输出最终结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

迭代分解能够适应未知问题,但必须设置最大迭代次数、预算和终止条件,防止无限扩展任务。

五、任务依赖关系与 DAG

复杂任务通常不能仅用列表表示。

例如:

T1:获取销售数据
T2:获取产品信息
T3:清洗销售数据
T4:关联产品信息
T5:统计销售指标
T6:分析销售原因
T7:生成报告

其中:

  • T3 依赖 T1。
  • T4 依赖 T2 和 T3。
  • T5 依赖 T4。
  • T6 依赖 T5。
  • T7 依赖 T6。

这种关系可以使用有向无环图(DAG,Directed Acyclic Graph)表示。

1. DAG 的基本结构

DAG 由节点和有向边组成:

  • 节点:表示一个任务。
  • 有向边:表示任务之间的依赖关系。
  • 无环:不存在从某个任务出发又回到自身的依赖路径。
flowchart TD
    A["T1:获取销售数据"] --> C["T3:清洗销售数据"]
    B["T2:获取产品信息"] --> D["T4:关联产品信息"]
    C --> D
    D --> E["T5:统计销售指标"]
    E --> F["T6:分析销售原因"]
    F --> G["T7:生成报告"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这里 T1 和 T2 没有直接依赖关系,因此可以同时执行。

当 T1 和 T2 均完成,并且 T3 完成后,T4 才具备执行条件。

2. DAG 的执行机制

DAG 通常使用拓扑排序确定任务的合法执行顺序。

拓扑排序可以得到满足依赖关系的任务顺序,但不意味着只有一种执行顺序。

例如:

T1、T2 可以并行
T3 必须等待 T1
T4 必须等待 T2 和 T3

调度器需要动态判断任务是否已经满足执行条件。

一个任务通常需要具备以下状态:

状态 含义
PENDING 等待执行
READY 依赖已满足,可以执行
RUNNING 正在执行
SUCCESS 执行成功
FAILED 执行失败
BLOCKED 被失败依赖阻塞
SKIPPED 根据条件被跳过
CANCELLED 已取消

3. DAG 与循环依赖

DAG 不允许存在循环依赖。

例如:

T1 依赖 T2
T2 依赖 T3
T3 依赖 T1

三个任务互相等待,没有任何任务可以启动。

因此,任务计划生成后,需要执行依赖关系校验:

  • 是否存在自依赖。
  • 是否存在循环依赖。
  • 是否存在不存在的依赖节点。
  • 是否存在无法到达的任务。
  • 是否存在永远无法满足的前置条件。

需要注意,业务过程可能需要反复迭代,但不应该直接在静态 DAG 中构造循环边。迭代应当通过显式循环控制、状态机或动态生成新任务来实现。

六、任务计划的数据结构

为了让 Planning 从语言描述转化为可执行结构,需要定义统一的任务模型。

一个任务至少应该包含以下字段:

字段 说明
task_id 唯一任务标识
name 任务名称
description 任务描述
inputs 输入参数
outputs 输出定义
dependencies 前置依赖
tool 使用的工具
status 执行状态
priority 优先级
timeout 超时时间
retry_policy 重试策略
completion_criteria 完成条件
risk_level 风险等级

示例:

{
  "task_id": "T5",
  "name": "计算销售指标",
  "description": "计算月度销售额、订单数和客单价",
  "inputs": {
    "dataset": "cleaned_sales_data"
  },
  "outputs": {
    "metrics": "MonthlySalesMetrics"
  },
  "dependencies": [
    "T4"
  ],
  "tool": "python_data_analyzer",
  "status": "pending",
  "priority": 2,
  "timeout": 60,
  "retry_policy": {
    "max_attempts": 3,
    "backoff": "exponential"
  },
  "completion_criteria": [
    "所有月份均生成统计结果",
    "指标计算通过校验"
  ],
  "risk_level": "low"
}

任务结构需要同时满足模型可理解和执行引擎可解析两个要求。

不能只依赖自然语言描述,否则调度器很难可靠地识别任务依赖、执行状态和重试条件。

七、Planning 的核心执行架构

在 Agent 系统中,Planning 通常不是一个独立的提示词,而是一组协同工作的模块。

典型架构包括:

模块 职责
Goal Parser 解析用户目标
Constraint Extractor 提取约束条件
Planner 生成任务计划
Task Decomposer 拆分复杂任务
Dependency Analyzer 分析任务依赖
Scheduler 决定任务执行时机
Executor 调用工具执行任务
State Manager 管理任务状态
Verifier 验证执行结果
Replanner 根据反馈重新规划

1. 整体架构

flowchart TD
    A["用户目标"] --> B["Goal Parser"]
    B --> C["Constraint Extractor"]
    C --> D["Planner"]
    D --> E["Task Decomposer"]
    E --> F["Dependency Analyzer"]
    F --> G["Task Plan / DAG"]
    G --> H["Scheduler"]
    H --> I["Executor"]
    I --> J["工具与外部系统"]
    J --> K["执行结果"]
    K --> L["Verifier"]
    L --> M{"任务是否完成"}
    M -->|"是"| N["更新任务状态"]
    M -->|"否"| O["Replanner"]
    O --> G
    N --> P{"整体目标是否完成"}
    P -->|"否"| H
    P -->|"是"| Q["输出最终结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style N fill:#EAF3EC,stroke:#83A995,color:#315D49
    style O fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style P fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style Q fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2. Planner:计划生成器

Planner 负责根据目标和约束生成计划。

输入通常包括:

  • 用户目标。
  • 当前对话上下文。
  • 可用工具清单。
  • 用户提供的数据。
  • 执行环境状态。
  • 预算和权限约束。

输出是结构化任务计划。

Planner 可以由大模型实现,也可以由规则引擎或传统规划算法实现。

3. Task Decomposer:任务分解器

Task Decomposer 将高层目标拆成更小的执行单元。

它需要判断:

  • 是否需要继续拆分。
  • 每个任务是否具有明确边界。
  • 是否存在任务依赖。
  • 哪些任务可以并行。
  • 是否需要子 Agent 处理。
  • 是否存在无法执行的任务。

任务分解不是越细越好。当任务已经具备明确输入、输出和完成条件时,通常没有必要继续拆分。

4. Scheduler:任务调度器

Scheduler 负责决定哪些任务可以执行。

它不负责理解复杂业务目标,而是根据任务依赖、优先级、资源和状态进行调度。

例如:

  • 依赖全部满足的任务进入 READY。
  • READY 任务按照优先级和资源限制分配执行槽位。
  • 执行成功后更新状态。
  • 失败后阻塞相关下游任务或触发恢复策略。

5. Verifier:任务验证器

Verifier 负责判断执行结果是否满足任务要求。

验证不能只看工具有没有返回成功,还需要检查:

  • 返回数据是否完整。
  • 数据格式是否正确。
  • 关键指标是否满足约束。
  • 结果是否与任务目标一致。
  • 是否存在异常或不可信内容。

Verifier 的结果可以触发任务通过、重试、修复或重新规划。

八、LLM 如何生成任务计划?

大模型是当前 Agent Planning 中常见的规划器实现方式。

它擅长理解自然语言目标、识别隐含约束、生成任务步骤,以及根据执行反馈调整计划。

但 LLM 输出的计划本质上仍然是候选方案,不能直接视为经过验证的可执行程序。

1. 规划提示词

可以为 Planner 定义明确的输出要求:

你是一个任务规划器。

根据用户目标生成结构化任务计划。

要求:
1. 将复杂目标拆分成可独立执行的子任务。
2. 每个任务必须有明确的输入和输出。
3. 明确任务之间的依赖关系。
4. 标记可以并行执行的任务。
5. 为每个任务定义完成条件。
6. 选择合适的工具。
7. 识别任务风险和执行约束。
8. 不要生成超出用户授权范围的操作。
9. 如果信息不足,明确指出缺失信息。
10. 输出符合指定 JSON Schema 的结果。

用户目标:
分析最近三个月的销售数据并生成报告。

2. 结构化计划输出

Planner 可以返回类似下面的结果:

{
  "goal": "生成最近三个月的销售分析报告",
  "tasks": [
    {
      "id": "T1",
      "name": "获取销售数据",
      "dependencies": [],
      "tool": "sales_data_api",
      "outputs": ["raw_data"]
    },
    {
      "id": "T2",
      "name": "获取产品信息",
      "dependencies": [],
      "tool": "product_api",
      "outputs": ["product_data"]
    },
    {
      "id": "T3",
      "name": "清洗销售数据",
      "dependencies": ["T1"],
      "tool": "python",
      "outputs": ["cleaned_data"]
    },
    {
      "id": "T4",
      "name": "关联产品信息",
      "dependencies": ["T2", "T3"],
      "tool": "python",
      "outputs": ["merged_data"]
    },
    {
      "id": "T5",
      "name": "统计销售指标",
      "dependencies": ["T4"],
      "tool": "python",
      "outputs": ["metrics"]
    },
    {
      "id": "T6",
      "name": "生成销售报告",
      "dependencies": ["T5"],
      "tool": "report_generator",
      "outputs": ["report"]
    }
  ]
}

结构化输出有利于后续调度和验证,但仍需要执行 Schema 校验、依赖校验、工具权限校验和业务规则校验。

3. 为什么不能完全相信 LLM 生成的计划?

LLM 生成计划时可能出现:

  • 引用不存在的工具。
  • 生成错误的参数。
  • 忽略必要的前置依赖。
  • 将不能并行的任务设置为并行。
  • 漏掉关键验收步骤。
  • 生成循环依赖。
  • 将高风险操作直接纳入执行计划。
  • 计划本身无法满足用户约束。

因此,生产环境通常采用混合规划架构:

LLM 负责理解和生成候选计划,确定性程序负责验证和调度。

九、Planning 与任务执行的协同

规划并不是一次性完成的静态过程。

Agent 在执行任务时,可能发现新信息、遇到异常或发现原始假设不成立,因此需要不断调整计划。

1. 静态规划与动态规划

类型 特点 适用场景
静态规划 执行前生成完整计划 规则明确、环境稳定
动态规划 根据执行反馈不断调整 环境变化、结果不确定
混合规划 先生成初始计划,再局部调整 大多数复杂 Agent 任务

静态规划有利于控制执行路径,但容易受到意外情况影响。

动态规划适应性更强,但会增加模型调用成本和执行不确定性。

实际系统通常采用混合规划:先形成可执行的初始计划,在必要时进行局部重规划。

2. 动态重规划

假设 Agent 在获取销售数据时发现某个数据源不可用。

原始计划:

T1:从数据源 A 获取销售数据
T2:清洗销售数据
T3:分析销售趋势
T4:生成报告

如果 T1 失败,Agent 可以选择:

  • 重试数据源 A。
  • 切换到数据源 B。
  • 使用已经授权的缓存数据。
  • 请求用户提供数据文件。
  • 终止任务并说明原因。

动态重规划的关键是保留已经成功完成的任务结果,而不是每次失败都重新执行整个计划。

3. 重规划的完整流程

flowchart TD
    A["执行当前任务"] --> B["收集执行结果"]
    B --> C["验证任务输出"]
    C --> D{"执行是否成功"}
    D -->|"是"| E["更新任务状态"]
    D -->|"否"| F["分析失败原因"]
    F --> G{"是否可以重试"}
    G -->|"是"| H["按重试策略重新执行"]
    H --> A
    G -->|"否"| I{"是否存在替代方案"}
    I -->|"是"| J["生成替代任务计划"]
    J --> K["验证新计划"]
    K --> L{"新计划是否合法"}
    L -->|"是"| M["更新任务图"]
    M --> A
    L -->|"否"| N["请求人工介入"]
    I -->|"否"| N
    E --> O["检查整体目标"]
    O --> P{"是否全部完成"}
    P -->|"是"| Q["输出最终结果"]
    P -->|"否"| A

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style N fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49
    style P fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style Q fill:#DCEFE5,stroke:#4F8B70,color:#24563F