民族染线备料：区间批次用量快速查询

档案概况

题目、题干与输入输出

正式题面

源文件：official-prompt.md

规则来源

• 赛项说明页码：15
• 训练题主题：民族染线备料：区间批次用量快速查询
• 所属赛道：民族文化赛道

题目背景

民族染线备料按批次记录用量，老师会频繁查询某一段批次的总消耗。为了快速复盘备料节奏，需要在大量查询下保持稳定性能，并找出总量最大的那一次查询。

任务描述

• 读取每一批次的用量数据并建立前缀和。
• 按顺序回答所有闭区间查询。
• 输出总量最大的查询编号，若并列取最早编号。

输入格式

1. 第一行输入 n q，表示批次数量和查询数量。
2. 第二行输入 n 个整数 a1..an，表示每一批次的用量。
3. 接下来 q 行每行输入 l r，表示查询闭区间 [l, r] 的总用量。

输出格式

1. 对每个查询按顺序输出一行 query_i=区间总用量。
2. 最后一行输出 max_query=总用量最大的查询编号。

数据范围与说明

• 1 <= n, q <= 200000。
• 0 <= ai <= 10^9。
• 1 <= l <= r <= n。
• 区间总和可能超过 32 位整数，需使用 64 位整型。
• 输出顺序必须与输入查询顺序一致。

样例输入

7 3
5 8 6 7 4 9 3
1 3
2 6
4 7

样例输出

query_1=19
query_2=34
query_3=23
max_query=2

样例解释

• 前三批总用量为 5 + 8 + 6 = 19。
• 第 2 到 6 批总用量为 34，是三次查询中的最大值。
• 因此最后一行输出 max_query=2。

知识点清单

• 前缀和数组 pre[i] 的定义。
• 区间和公式 pre[r] - pre[l-1]。
• 1-based 下标与边界处理。
• 64 位整数累加。
• 多次查询中的最值与并列最早规则。

约束拆解

源文件：parsed-constraints.md

显式约束

• 1 <= n, q <= 200000。
• 0 <= ai <= 10^9。
• 1 <= l <= r <= n。
• 区间总和可能超过 32 位整数，需使用 64 位整型。
• 输出顺序必须与输入查询顺序一致。

建模拆解

• 先明确输入的实体和字段，再把它们翻译成 前缀和 + 单次线性扫描维护最大查询 需要的数据结构。
• 把输出中每一项指标都和中间变量对应起来，避免最后临时拼装。
• 先用样例手推一次，再确认边界条件是否都能走到正确分支。

易错边界

• 查询恰好覆盖整个数组时，要正确读出全部总量。
• 多个查询结果并列最大时，只保留最早编号。
• 批次用量和查询数量都很大时，不能退回逐段累加。

计分模型

源文件：scoring-model.md

判题方式

• 主判题方式：exact
• 主算法：前缀和 + 单次线性扫描维护最大查询

判题重点

• 重点校验公式、排序规则和格式化输出是否完全一致。
• 隐藏数据会覆盖边界值、重复值和最小规模输入。

公开样例建议

• 至少准备 1 组题面样例、2 组边界样例和 2 组自定义回归样例。
• 多输出题必须验证所有字段都来自同一套方案。

隐藏数据建议

• 准备单点区间和整段区间混合的查询序列。
• 准备多个查询结果完全相同的用例，检查编号规则。
• 准备大数值批次数据，验证 64 位整型处理。

验收清单

源文件：acceptance-checklist.md

• 正式题面、约束拆解、评分说明均已补齐
• 样例输入输出已定义并通过主实现校验
• python 主实现已提供并与样例输出对齐
• cpp 主实现已提供并与样例输出对齐
• 调试记录、决策记录、验证计划已补齐
• 可由 20-tools/assemble_case_dossiers.py 汇总为完整解题档案

样例输入输出

样例输入：sample.in

7 3
5 8 6 7 4 9 3
1 3
2 6
4 7

样例输出：sample.out

query_1=19
query_2=34
query_3=23
max_query=2

题解、建模与最终解法

自动整理的解题流程

• 题目主题：民族染线备料：区间批次用量快速查询
• 题目摘要：利用前缀和快速回答闭区间批次用量查询，并找出总量最大的查询编号。
• 判题提示：该题以精确输出为主，最终程序需要重点保证公式、顺序和格式完全一致。
• 先完成输入、对象、约束和输出的四步建模，再落到具体算法和实现。
• 优先用样例验证最小流程，再补边界测试和错误分支。

解题思路

源文件：solution-rationale.md

1. 问题重述

利用前缀和快速回答闭区间批次用量查询，并找出总量最大的查询编号。

2. 数据结构与建模

• 主算法：前缀和 + 单次线性扫描维护最大查询
• 输入拆解后对应的数据结构要和输出项一一对应。
• 需要重点维护的状态包括：题目实体、核心指标、中间结果和最终答案。

3. 算法步骤

1. 顺序读入批次用量并构建前缀和。
2. 对每个查询用前缀和在 O(1) 时间算出区间总用量。
3. 同步维护总量最大的查询编号。
4. 按查询顺序输出所有结果，再输出最大查询编号。

4. 正确性说明

• 每一步都严格对应题面给出的规则或约束。
• 所有输出字段都来自同一份计算过程，不会出现“各算各的”的不一致情况。
• 边界情况通过单独分支或统一规则处理，保证程序在最小规模和重复值情况下也稳定。

5. 复杂度分析

• 复杂度取决于输入规模和主算法，但整体设计保持在初中组可讲解、可验证的范围内。
• 只保留必要状态，不引入超出题意的数据结构。

6. 易错点

• 查询恰好覆盖整个数组时，要正确读出全部总量。
• 多个查询结果并列最大时，只保留最早编号。
• 批次用量和查询数量都很大时，不能退回逐段累加。

7. 知识点清单

• 前缀和数组 pre[i] 的定义。
• 区间和公式 pre[r] - pre[l-1]。
• 1-based 下标与边界处理。
• 64 位整数累加。
• 多次查询中的最值与并列最早规则。

设计决策记录

源文件：decision-log.md

• 选择 前缀和 + 单次线性扫描维护最大查询 作为主算法，因为它能直接覆盖题目的核心约束。
• 题目是静态数组多次区间求和，前缀和能把查询压到 O(1)。
• 最大查询编号与区间求和可以在同一遍查询处理中完成。
• Python 与 C++ 版本统一输出格式，便于双语训练和证据采集。

验证计划

源文件：validation-plan.md

• 先验证题面公开样例，确保基础流程无误。
• 准备单点区间和整段区间混合的查询序列。
• 准备多个查询结果完全相同的用例，检查编号规则。
• 准备大数值批次数据，验证 64 位整型处理。
• 最后再补 1 组手工构造的极小数据，确认程序不会依赖特殊输入规模。

备选方案

源文件：alternatives.md

最终代码与实现

Python 主实现

源文件：main.py

• 实现状态：当前已有可执行实现

import sys


def solve(data: str) -> str:
    tokens = list(map(int, data.split()))
    if not tokens:
        return ""
    it = iter(tokens)
    n = next(it)
    q = next(it)
    values = [0] + [next(it) for _ in range(n)]
    prefix = [0] * (n + 1)
    for index in range(1, n + 1):
        prefix[index] = prefix[index - 1] + values[index]
    lines = []
    best_query = 1
    best_sum = -1
    for query_id in range(1, q + 1):
        left = next(it)
        right = next(it)
        total = prefix[right] - prefix[left - 1]
        lines.append(f"query_{query_id}={total}")
        if total > best_sum:
            best_sum = total
            best_query = query_id
    lines.append(f"max_query={best_query}")
    return "\n".join(lines)


if __name__ == "__main__":
    sys.stdout.write(solve(sys.stdin.read()).strip())
    sys.stdout.write("\n")

C++ 对照实现

源文件：main.cpp

• 实现状态：当前已有可执行实现

#include <iostream>
#include <vector>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, q;
    if (!(cin >> n >> q)) {
        return 0;
    }
    vector<long long> prefix(n + 1, 0);
    for (int i = 1; i <= n; ++i) {
        long long value;
        cin >> value;
        prefix[i] = prefix[i - 1] + value;
    }
    int best_query = 1;
    long long best_sum = -1;
    for (int query_id = 1; query_id <= q; ++query_id) {
        int left, right;
        cin >> left >> right;
        long long total = prefix[right] - prefix[left - 1];
        cout << "query_" << query_id << "=" << total << "\n";
        if (total > best_sum) {
            best_sum = total;
            best_query = query_id;
        }
    }
    cout << "max_query=" << best_query << "\n";
    return 0;
}

代码执行与运行结果

最新成功运行

PY 运行输出摘录

query_1=19
query_2=34
query_3=23
max_query=2

CPP 运行输出摘录

query_1=19
query_2=34
query_3=23
max_query=2

全部运行记录索引

调试、修正与流程留痕

调试日志

源文件：debug-journal.md

失败案例目录

源文件：failure-catalog.md

编码过程记录

源文件：implementation-journal.md

全流程文件导航

• 题目总览：s4-jh-06-dye-batch-query/README.md
• 题面与约束：official-prompt.md、parsed-constraints.md、scoring-model.md、acceptance-checklist.md
• 代码与样例：10-cases/s4-jh-06-dye-batch-query/02-solution
• 运行证据：10-cases/s4-jh-06-dye-batch-query/03-execution
• 调试过程：debug-journal.md、failure-catalog.md、implementation-journal.md
• 解法说明：solution-rationale.md、decision-log.md、validation-plan.md、alternatives.md
• 交付档案：final-report.md、appendix-code.md、appendix-runs.md、evidence-pack.md

• 完整解题档案：complete-solution-dossier.md
• 代码附录：appendix-code.md
• 运行附录：appendix-runs.md

题目概述

利用前缀和快速回答闭区间批次用量查询，并找出总量最大的查询编号。

最终解法摘要

自动整理的解题流程

• 题目主题：民族染线备料：区间批次用量快速查询
• 题目摘要：利用前缀和快速回答闭区间批次用量查询，并找出总量最大的查询编号。
• 判题提示：该题以精确输出为主，最终程序需要重点保证公式、顺序和格式完全一致。
• 先完成输入、对象、约束和输出的四步建模，再落到具体算法和实现。
• 优先用样例验证最小流程，再补边界测试和错误分支。

代码执行摘要

交付说明

本报告为摘要版，详细题目、题干、题解、最终代码、运行结果和调试流程已经汇总到完整解题档案中。