你好！这是一个非常好的需求。编写数据生成器（Data Generator）是OI教练和出题人的必备技能。

为了确保生成的测试数据既规范又能覆盖各种考察点（特别是数据溢出、边界条件），我将提供一个 C++数据生成器。这个程序会自动生成 1.in ~ 10.in 和对应的 1.out ~ 10.out。

📊 测试点策略设计 (Test Case Strategy)

为了全面考察学生代码，我们将10个测试点分配如下：

• 测试点 1-2 (基础题): $N$ 很小，数值很小。手动可算，用于排查基本逻辑错误。
• 测试点 3-4 (必然成功): 构造数据，计算出总消耗量，然后让初始燃料 $M$ 大于总消耗。考察输出剩余燃料的格式。
• 测试点 5-6 (必然失败): 构造数据，让 $M$ 很小，迫使在中途耗尽。考察失败时的运行时间累加逻辑。
• 测试点 7 (边界-最小值): $N=1, T=1, P=1, K=1$。最简情况。
• 测试点 8 (边界-最大 $N$): $N=1000$ (GESP4常见规模)，考察循环是否正常。
• 测试点 9 (数据类型陷阱): $M$ 和消耗量极大，逼近 long long 极限，考察是否使用了 long long。
• 测试点 10 (精确边界): 构造一个刚好油量为 0 跑完，或者差 1 单位油跑完的情况，考察边界判断（>= 还是 >）。

💻 数据生成器完整代码 (C++14)

请将以下代码保存为 generator.cpp，编译运行即可在当前目录下生成20个文件。

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <random>
#include <algorithm>
#include <chrono>

using namespace std;

// ==========================================
// 1. 标准题解函数 (Solver)
// 用于读取生成的 .in 文件并产生标准的 .out 文件
// ==========================================
void solve(const string& inFilename, const string& outFilename) {
    ifstream fin(inFilename);
    ofstream fout(outFilename);
    
    if (!fin.is_open() || !fout.is_open()) {
        cerr << "Error opening files: " << inFilename << endl;
        return;
    }

    long long n, m, k;
    if (!(fin >> n >> m >> k)) return;

    long long total_time = 0;
    bool is_success = true;

    for (int i = 0; i < n; i++) {
        long long p, t;
        fin >> p >> t;

        // 如果之前已经失败，需要继续读取数据但不处理逻辑
        // 但题目是顺序结构，为了模拟到位，我们按逻辑走
        if (!is_success) continue;

        // 核心计算
        long long cost_per_sec = p * k;
        
        // 这里的乘法在极大数据下可能溢出，但我们在生成数据时会控制范围
        // 保证单步消耗不超过 long long
        long long needed_fuel = cost_per_sec * t;

        if (m >= needed_fuel) {
            m -= needed_fuel;
            total_time += t;
        } else {
            is_success = false;
            // 能够维持的完整秒数
            if (cost_per_sec > 0) {
                total_time += m / cost_per_sec;
            }
            // 失败后逻辑上应该停止，但在循环中可以通过 flag 控制
        }
    }

    if (is_success) {
        fout << "Success" << endl;
        fout << m << endl;
    } else {
        fout << "Fail" << endl;
        fout << total_time << endl;
    }

    fin.close();
    fout.close();
}

// ==========================================
// 2. 随机数生成器辅助类
// 使用 mt19937_64 保证随机性和生成大整数的能力
// ==========================================
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

long long random_range(long long min, long long max) {
    if (min > max) return min;
    uniform_int_distribution<long long> dist(min, max);
    return dist(rng);
}

// ==========================================
// 3. 数据生成核心逻辑
// ==========================================
void generate_data(int id) {
    string inName = to_string(id) + ".in";
    string outName = to_string(id) + ".out";
    
    ofstream fout(inName);
    
    // 参数定义
    long long N, M, K;
    vector<pair<long long, long long>> instructions; // 存 P 和 T

    // --- 根据测试点 ID 设定不同策略 ---
    
    if (id <= 2) { 
        // [1-2] 小数据，基础测试
        N = 5;
        K = random_range(1, 5);
        // 生成指令
        for(int i=0; i<N; i++) instructions.push_back({random_range(10, 100), random_range(1, 10)});
        // 随机 M，一半概率够，一半概率不够
        long long total_need = 0;
        for(auto p : instructions) total_need += p.first * K * p.second;
        if (id == 1) M = total_need + 50; // 成功
        else M = total_need / 2;          // 失败
    } 
    else if (id <= 4) {
        // [3-4] 必然成功，数据适中
        N = random_range(20, 50);
        K = random_range(10, 100);
        for(int i=0; i<N; i++) instructions.push_back({random_range(1, 100), random_range(10, 100)});
        
        long long total_need = 0;
        for(auto p : instructions) total_need += p.first * K * p.second;
        // 设定 M 比需求大
        M = total_need + random_range(100, 10000);
    } 
    else if (id <= 6) {
        // [5-6] 必然失败，M 较小
        N = random_range(20, 50);
        K = random_range(10, 100);
        for(int i=0; i<N; i++) instructions.push_back({random_range(50, 100), random_range(10, 100)});
        
        long long total_need = 0;
        for(auto p : instructions) total_need += p.first * K * p.second;
        // 设定 M 为需求的一部分
        M = total_need / random_range(2, 4); 
    }
    else if (id == 7) {
        // [7] 极小边界
        N = 1;
        K = 1;
        instructions.push_back({1, 1}); // P=1, T=1
        M = 0; // 0油能不能跑？不能。应该Fail，时间0。
    }
    else if (id == 8) {
        // [8] N 较大 (GESP 4级规模)
        N = 1000;
        K = 10;
        for(int i=0; i<N; i++) instructions.push_back({random_range(1, 100), random_range(1, 100)});
        // 随机 M
        M = random_range(100000, 10000000);
    }
    else if (id == 9) {
        // [9] 大整数溢出测试 (Long Long)
        N = 10;
        K = 100000; // K很大
        for(int i=0; i<N; i++) instructions.push_back({100, 10000}); // P=100, T大
        // 单步消耗 = 100 * 100000 * 10000 = 10^11，不会爆long long
        // 总消耗约 10^12
        M = 2000000000000LL; // 2e12
    }
    else {
        // [10] 精确边界测试
        // 构造一个刚好油耗尽的情况
        N = 3;
        K = 2;
        instructions.push_back({50, 10}); // 50*2*10 = 1000
        instructions.push_back({100, 5}); // 100*2*5 = 1000
        instructions.push_back({10, 10}); // 10*2*10 = 200
        // 总需 2200
        // 情况A: 刚好够 -> M = 2200 -> Success, Rem: 0
        // 情况B: 差一点 -> M = 2199 -> Fail, Time?
        // 我们这里随机生成这两种情况之一
        long long total = 2200;
        if (random_range(0, 1)) M = total; 
        else M = total - 1; 
    }

    // --- 写入 .in 文件 ---
    fout << N << " " << M << " " << K << endl;
    for (auto p : instructions) {
        fout << p.first << " " << p.second << endl;
    }
    fout.close();

    // --- 调用 Solver 生成 .out 文件 ---
    solve(inName, outName);
    
    cout << "Generated Case " << id << ": N=" << N << ", M=" << M << " -> Done." << endl;
}

int main() {
    // 提高随机种子质量
    // 循环生成 1 到 10
    for (int i = 1; i <= 10; i++) {
        generate_data(i);
    }
    
    cout << "\nAll 10 test cases generated successfully!" << endl;
    return 0;
}

🧠 代码设计思路与优化说明

1. 架构分离：

   • solve()：这是标准的题解逻辑。直接内嵌在生成器中，保证 .out 文件与 .in 文件的逻辑绝对一致。
   • generate_data(id)：针对每个 ID 定制生成策略。

2. 数据范围控制（防止溢出）：

   • 虽然题目背景是猛禽发动机，但为了防止生成的数据在计算过程中直接超过 C++ long long 的范围（$9 \times 10^{18}$），我在生成 K 和 T 时做了限制。
   • 例如在第9个点（大整数测试），$K=10^5, T=10^4, P=100$，乘积约为 $10^{11}$，这远小于 long long 的上限，但足以让使用 int 的学生代码溢出（int 上限约 $2 \times 10^9$）。这是非常经典的坑点。

3. 边界情况覆盖：

   • ID 7: $M=0$。这是一个很容易被忽视的情况，程序应当输出 Fail 且时间为 0。
   • ID 10: 刚好够油 vs 差 1 滴油。这是检验逻辑严密性的试金石。

4. 时间复杂度：

   • 生成器本身非常轻量，每个测试点生成的时间复杂度为 $O(N)$。
   • 即使 $N=1000$，生成所有数据也是毫秒级的。

5. 随机性优化：

   • 使用了 std::mt19937_64，比传统的 rand() 质量更高，且支持生成 64 位的大随机数。

🚀 如何使用

1. 将上述代码保存为 gen.cpp。
2. 编译：g++ gen.cpp -o gen -std=c++14
3. 运行：./gen (Windows下是 gen.exe)
4. 你的目录下会出现 1.in...10.in 和 1.out...10.out。
5. 把这些文件上传到你的 OJ 后台即可。

这套数据能有效区分出：

• ❌ 忘记开 long long 的（在 Test 9 挂掉）
• ❌ 逻辑混乱、模拟错误的（在 Test 5, 6, 10 挂掉）
• ✅ 满分选手（全通过）

你好！我是你的OI金牌教练。

看到你已经跃跃欲试，想要像SpaceX工程师一样解决这个问题了。下面是一份符合 NOIP C++14 竞赛标准 的题解代码。

这份代码不仅能通过GESP 4级的测试，还融入了许多高阶竞赛（CSP-J/S, NOIP）中必须养成的**“防爆零”好习惯**（比如数据类型选择、边界处理）。

💻 标准题解代码 (C++14)

/*
 * 题目：猛禽之火：长程点火测试 (Raptor Test Simulation)
 * 作者：OI Coach
 * 难度：GESP 4级 / CSP-J 普及组第一题难度
 * 算法：模拟 (Simulation)、贪心 (Greedy approach to time)
 */

#include <iostream>
// 在NOIP/CSP中，通常不需要包含过多头文件，<iostream>足够
// 如果使用了特定算法，可能需要 <algorithm> 或 <vector>

using namespace std;

int main() {
    // 1. 提升I/O效率 (竞赛常用技巧，防止输入数据量过大时超时)
    ios::sync_with_stdio(false);
    cin.tie(0);

    // 2. 变量定义
    // 关键点：燃料M可能很大，计算过程中的消耗量(P*K*T)也极易爆int。
    // 必须使用 long long，这是新手最容易丢分的地方！
    long long n;          // 指令数量
    long long m;          // 初始燃料 (long long防止溢出)
    long long k;          // 单位消耗系数
    
    if (!(cin >> n >> m >> k)) return 0; // 健壮性读取

    long long total_time = 0;   // 记录成功运行的总时间
    bool is_success = true;     // 标记最终是否成功

    // 3. 循环处理每一条指令
    for (int i = 0; i < n; i++) {
        long long p, t; // 推力百分比，持续时间
        cin >> p >> t;

        // 如果已经失败了，剩下的指令虽然需要读入（为了防止输入流错乱），
        // 但不需要逻辑处理。或者可以直接 break，取决于题目是一次性输入还是多组数据。
        // 在单组数据的OI题中，break是安全的。
        if (!is_success) {
            continue; 
            // 注意：这里用continue配合上面的flag是为了读完数据。
            // 如果题目数据保证之后不再读入，可以直接 break。
            // 为了代码逻辑最简，我们下面直接在判定失败后 break。
        }

        // 关键计算：当前阶段每秒消耗量
        long long cost_per_sec = p * k; 
        
        // 关键计算：当前阶段需要的总燃料
        // 易错点：这里 p * k * t 可能会非常大，必须确保变量是 long long
        long long needed_fuel = cost_per_sec * t;

        // 4. 核心逻辑判断
        if (m >= needed_fuel) {
            // 情况A：燃料足够跑完这个阶段
            m -= needed_fuel;      // 扣除燃料
            total_time += t;       // 累加时间
        } else {
            // 情况B：燃料不够跑完这个阶段
            is_success = false;    // 标记失败
            
            // 关键逻辑：计算剩下的燃料还能坚持几秒
            // 利用整数除法向下取整的特性
            // 例如：剩100油，每秒耗200，100/200 = 0秒，符合题意
            long long run_seconds = m / cost_per_sec; 
            
            total_time += run_seconds; // 加上还能跑的时间
            
            // 燃料理论上耗尽或不足以支撑下一秒，不必更新 m，直接退出
            break; 
        }
    }

    // 5. 格式化输出
    if (is_success) {
        cout << "Success" << endl;
        cout << m << endl;         // 输出剩余燃料
    } else {
        cout << "Fail" << endl;
        cout << total_time << endl; // 输出总运行时间
    }

    return 0;
}

🧐 复杂度分析与思考过程

1. 时间复杂度 (Time Complexity)

• 分析：
  • 代码主要包含一个 for 循环，循环次数为 $N$。
  • 在循环内部，无论是加减乘除运算，还是 if 判断，都是 $O(1)$ 的常数时间操作。
  • 我们没有使用嵌套循环去“一秒一秒”地模拟（那是 $O(\sum T_i)$ 的做法）。
• 结论：时间复杂度为 $O(N)$。
• 意义：
  • 如果 $N=1000$，计算机瞬间完成。
  • 即使 $T_i$（时间）是 100亿秒，我们的数学计算法也能一步到位，不会超时。
  • 金牌教练提示：这就是“数学优化模拟”的力量。在OI中，能用数学公式算出来的，绝不跑循环。

2. 空间复杂度 (Space Complexity)

• 分析：
  • 我们只定义了 n, m, k, p, t 等几个变量。
  • 并没有开设数组 a[1000] 来存储所有指令（虽然 $N$ 很小的时候开数组也可以）。我们采用了“在线处理”模式，读一个处理一个。
• 结论：空间复杂度为 $O(1)$。
• 意义：极度节省内存，适合处理大规模数据流。

⚠️ 金牌教练的“防坑”指南 (易错点总结)

1. 数据类型的陷阱 (long long)：

   • 题目中 $M$ 是燃料。如果这是真实的猛禽发动机测试，$P \times K \times T$ 算出来的消耗量很容易超过 int 的范围（约 21亿）。
   • 习惯：在涉及累加、乘积判断的题目中，除非明确数据极小，否则无脑首选 long long。这能挽救你 30% 到 100% 的分数。

2. 整除的妙用：

   • 代码中 long long run_seconds = m / cost_per_sec;
   • 很多同学会去写循环：while(m >= cost) { m-=cost; sec++; }。
   • 千万别这么写！如果 $M$ 剩 1亿，每次耗 1，循环就要跑 1亿次。直接用除法是 $O(1)$ 的。

3. 失败后的处理：

   • 题目要求一旦失败输出“总成功运行时间”。
   • 要注意是 total_time += run_seconds，这里的 run_seconds 是当前这个失败阶段里勉强跑完的时间，不要忘记加进去。

4. IO优化：

   • 虽然 GESP 4级数据量不大，但在 cin >> 次数很多（比如 $N=10^5$）时，ios::sync_with_stdio(false); 是必备的。

希望这份代码和分析能帮你彻底吃透这道题！就像猛禽3号一样，编写代码也要追求极致的效率和稳定性！🚀