太棒了！作为一名教练，我非常赞赏你不仅关注解法，还开始自己动手出测试数据。这也是算法学习进阶的重要标志——掌握数据生成（Data Generation）能让你更加深刻地理解题目的边界情况（Corner Cases）和算法的脆弱点。

虽然这道题目的数据范围只有 $A \le 1000$，无论是 $O(A^2)$ 还是 $O(\sqrt{A})$ 在这个数据量级下都能瞬间运行完毕（无法在真实 OJ 中卡掉 $O(A)$ 解法），但我们依然要秉承**“覆盖全部边界与特殊结构”**的原则来设计测试用例。

下面是为你准备的 C++14 数据生成器代码。

核心设计思路（10 个测试点分布）

为了全面考察代码逻辑，我精选了 10 个代表性的数值：

1. 测试点 1 (A=2)：最小值边界，同时也是质数。
2. 测试点 2 (A=4)：较小的完全平方数（也是样例1），测试对正方形长宽相同的处理。
3. 测试点 3 (A=6)：较小的普通数（也是样例2），没有平方根等特殊情况。
4. 测试点 4 (A=12)：我在教学推导中使用的数，帮助验证草稿纸逻辑。
5. 测试点 5 (A=997)：大质数。答案应该是 1。考察是否能正确判断大质数。
6. 测试点 6 (A=900)：较大的完全平方数。进一步测试 w * w <= A 边界处理是否正确。
7. 测试点 7 (A=840)：高合成数（反素数）。它是 1000 以内拥有最多因数（32个因数）的数，用来测试在极多匹配项时的计算。
8. 测试点 8 (A=1000)：最大值边界。
9. 测试点 9 (A=512)：2 的次幂（$2^9$）。专门测试全是同一个质因子的特殊情况。
10. 测试点 10 (A=960)：接近 1000 的大数，且拥有大量因数（28个），增加一组复合测试。

数据生成器完整 C++ 代码 (generator.cpp)

请将以下代码保存为 generator.cpp 并在同一目录下编译运行，它会自动生成 1.in ~ 10.in 和 1.out ~ 10.out 共 20 个文件。

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

// 标程函数：使用最优 O(sqrt(A)) 复杂度生成标准答案
int solve(int A) {
    int ans = 0;
    // 采用 w * w <= A，不使用开方，防止精度问题，避免超时
    for (int w = 1; w * w <= A; ++w) {
        if (A % w == 0) {
            ans++;
        }
    }
    return ans;
}

int main() {
    // 优化系统 IO 速度
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // 精心设计的 10 个测试点
    vector<int> test_cases = {
        2,    // Test 1: 最小值边界，质数
        4,    // Test 2: 样例 1，最小完全平方数
        6,    // Test 3: 样例 2
        12,   // Test 4: 草稿推导案例
        997,  // Test 5: 1000以内最大质数 (只有1种拼法: 997*1)
        900,  // Test 6: 较大的完全平方数 (刚好 w=30时, w*w=900)
        840,  // Test 7: 1000以内因数最多的数(高合成数)，共有32个因数
        1000, // Test 8: 题目约定数据范围的最大值边界
        512,  // Test 9: 纯 2 的次幂结构 (2^9)
        960   // Test 10: 接近上限的复杂数字，包含多个2, 3, 5质因子
    };

    // 循环生成 10 组测试数据
    for (int i = 0; i < test_cases.size(); ++i) {
        int A = test_cases[i];
        
        // --- 1. 生成 .in 文件 ---
        string in_filename = to_string(i + 1) + ".in";
        ofstream fout_in(in_filename);
        if (!fout_in.is_open()) {
            cerr << "无法创建文件: " << in_filename << "\n";
            continue;
        }
        fout_in << A << "\n";
        fout_in.close();

        // --- 2. 调用标程计算正确答案 ---
        int ans = solve(A);

        // --- 3. 生成 .out 文件 ---
        string out_filename = to_string(i + 1) + ".out";
        ofstream fout_out(out_filename);
        if (!fout_out.is_open()) {
            cerr << "无法创建文件: " << out_filename << "\n";
            continue;
        }
        fout_out << ans << "\n";
        fout_out.close();

        // 终端输出生成日志，方便教练/出题人确认
        cout << "成功生成 Test " << (i + 1) 
             << " | A = " << A 
             << " | 答案 = " << ans << "\n";
    }

    cout << "\n所有测试数据生成完毕！文件都在当前目录下。" << endl;
    return 0;
}

OJ 出题与测试数据评估说明

1. 文件大小评估：由于每个 .in 和 .out 文件仅包含 1 个不超过四位数的整数和一个换行符，单文件大小均为 2~5 字节。全部 20 个文件总计不超过 100 Byte，完全符合且远低于 2MB 的要求，OJ 平台评测读取将是极速的。
2. 时间复杂度卡点说明：这道题题意给定 $2 \le A \le 1000$。即使是最暴力的 $O(A^2)$ 算法也只需运行 $10^6$ 次计算（毫秒级）。如果要严格按照“部分AC，部分超时”来卡住暴力解法，在 OJ 设置题目时，教练强烈建议你将后台的数据范围扩大：
   • 如果你想卡掉 $O(A^2)$ 但放过 $O(A)$，可以将范围设为 $A \le 10^5$。
   • 如果你想同时卡掉 $O(A^2)$ 和 $O(A)$，只允许我们最后推导的最优解 $O(\sqrt{A})$ 通过，需要在题目后台悄悄加入一两个 $A = 10^{10}$ 或 $A = 10^{12}$ 级别的测试点（注意此时要使用 long long 类型！）。

你好！既然我们已经理清了思路，接下来教练就带你把刚才在草稿纸上的想法，一步步落实到真正的代码中去。

在学习算法的过程中，我们提倡**“先求正确，再求最优”**。下面我会给你展示三个版本的完整代码，它们从最直观的暴力破解，逐渐演进到极其精简优雅的最优解。所有的代码都严格遵守 NOIP/CSP C++14 的比赛标准。

版本一：小白直觉版 —— 双重循环暴力枚举

很多初学者看到“长和宽”，第一反应是：我把所有的长和所有的宽都试一遍，看看哪个拼起来面积刚好等于 $A$！

#include <iostream>

using namespace std;

int main() {
    // 优化输入输出速度，竞赛常用起手式
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int A;
    cin >> A;

    int ans = 0; // 记录满足条件的长方形种数

    // 易错点1：长和宽最少是 1，不能从 0 开始，否则相乘为 0 且除法会报错
    // 外层循环枚举宽 W
    for (int w = 1; w <= A; ++w) {
        // 内层循环枚举长 L
        for (int l = 1; l <= A; ++l) {
            // 关键点1：面积必须等于 A
            // 关键点2：根据题意，长必须大于等于宽
            if (w * l == A && l >= w) {
                ans++;
            }
        }
    }

    cout << ans << "\n";

    return 0;
}

【复杂度分析与思考】

• 空间复杂度：$O(1)$。只用了 A, ans, w, l 几个整型变量，非常省空间。
• 时间复杂度：$O(A^2)$。嵌套了两个长度为 $A$ 的循环，总共执行了 $A \times A$ 次判断。
• 优化思考：这题 $A \le 1000$，$1000^2 = 1,000,000$（一百万），计算机一秒能跑一亿次，所以肯定能 AC。但如果你仔细想，当我已经确定 w 之后，l 根本不需要从头试到尾啊！因为 $l = A \div w$，这就可以去掉一层循环！

版本二：数学降维版 —— 单重循环枚举

我们利用数学公式 $A = \text{长} \times \text{宽}$，直接推导出“长”，这样就把 $O(N^2)$ 降维打击成了 $O(N)$。

#include <iostream>

using namespace std;

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

    int A;
    cin >> A;

    int ans = 0;

    // 我们只需要枚举宽 w 即可
    for (int w = 1; w <= A; ++w) {
        // 关键点1：如果 A 不能被 w 整除，说明算出来的长不是整数，直接跳过
        if (A % w == 0) {
            int l = A / w; // 算出对应的长
            
            // 关键点2：只有当算出来的长 >= 宽 时，才符合题意
            if (l >= w) {
                ans++;
            }
        }
    }

    cout << ans << "\n";

    return 0;
}

【复杂度分析与思考】

• 空间复杂度：$O(1)$。
• 时间复杂度：$O(A)$。只需要一个循环，执行 $A$ 次。如果是 $A=1000$，只跑 1000 次，比上一个版本快了 1000 倍。
• 优化思考：我们观察这个循环，当 w 越来越大，算出来的 l 就越来越小。一旦发现 l < w 了，后面的循环还有必要做吗？比如 $A=12$，当 w=4 时 l=3，此时不满足 l >= w。且接下来 w=5, 6... 时，l 只会越来越小，永远不可能再满足 l >= w 了。那我们是不是可以提前结束循环？

版本三：竞赛标答版 —— 极简最优复杂度（推荐掌握）

顺着版本二的思路，宽的最大值其实就在“长宽相等”也就是正方形的时候。所以，宽只需要遍历到面积的平方根即可。

#include <iostream>
// 不需要包含 <cmath> 来调用 sqrt()，我们有更优雅的写法

using namespace std;

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

    int A;
    cin >> A;

    int ans = 0;

    // 关键点1（时间复杂度优化的核心）：
    // 我们不写 w <= sqrt(A) 也不写 w <= A
    // 而是写 w * w <= A。
    // 这是一种避免浮点数开根号导致精度误差的经典竞赛写法！
    for (int w = 1; w * w <= A; ++w) {
        // 只要能整除，因为我们在 w * w <= A 的限制下，
        // 算出来的长 A/w 必定会 >= w，所以不需要再用 if (l >= w) 去判断了！
        if (A % w == 0) {
            ans++;
        }
    }

    cout << ans << "\n";

    return 0;
}

【复杂度分析与思考】

• 空间复杂度：$O(1)$。
• 时间复杂度：$O(\sqrt{A})$。
• 教练点评：这就是这道题在考场上满分的标准答案，代码极短，但蕴含了深刻的数理逻辑！当 $A = 1000$ 时，这段循环最多只运行 $\approx 31$ 次。
  • 如果在未来的提高组或者省选比赛中，题目把条件改成 $A \le 10^{12}$，
  • 版本一需要运行 $10^{24}$ 次，直接超时爆零；
  • 版本二需要运行 $10^{12}$ 次，大约需要几十秒，依然超时（TLE）；
  • 版本三只需要运行 $10^6$ 次，0.005 秒瞬间通过！

总结： 从这题你可以体会到，“优化算法就是减少不必要的操作”。以后在写代码之前，先在草稿纸上模拟一遍极限情况，把多余的尝试切断（我们称之为“剪枝”），你就能写出让阅卷机惊讶的超快代码。加油！

你好！很高兴能以教练的身份指导你。这道题虽然简单，但它是非常好的思维训练素材。我们一步一步来，不急于写代码，先理清思路。

1. 教练的思路提示（不提供完整代码）

• 提示一：数学转换。长方形的面积公式是 $A = \text{长} \times \text{宽}$。既然长和宽都是整数，这意味着宽和长必须是面积 $A$ 的因数（约数）。也就是 $A$ 必须能被宽整除。
• 提示二：唯一性限制。题目规定“长 $\ge$ 宽”，且“长宽相等的认为是同一种”。这就意味着我们不需要把所有情况都找一遍，我们只要让“宽”从小到大变化，并且保证“宽 $\le$ 长”，就能不重不漏地数出来。
• 提示三：缩小范围。如果已知面积是 $A$，宽是 $W$，那么长就可以直接用 $A \div W$ 算出来。我们有必要让 $W$ 一直循环到 $A$ 吗？想想看，$W$ 最大能到多少，才不会超过长呢？

2. 预备知识点总结

要解决这道题，你需要掌握以下几个基础知识点：

1. 基础数学：整数的乘除法、因数（约数）的概念、平方根的初步理解。
2. 分支与循环结构：for 或 while 循环（用于枚举可能的边长），if 条件判断（用于判断是否能整除）。
3. 取模运算（求余数）：在编程中，判断 $A$ 能否被 $B$ 整除，通常使用 A % B == 0。
4. 计数器思想：设定一个变量（如 count = 0），每找到一个满足条件的答案，就让 count = count + 1。

3. 启发式与图形式的草稿纸推导（教学模拟）

“来，同学，拿出一张草稿纸和一枝笔。我们不看题目的 4 和 6，我们用稍微大一点的数字，假设面积 A = 12。”

第一步：画图与列举（寻找直觉）

我们在纸上列一个表格，假设宽从 1 开始慢慢变大：

[草稿纸推导] 面积 A = 12

 宽(W) | 长(L = 12/W) | 能否整除? | 是否满足 长 >= 宽?
------------------------------------------------------
  1    |     12      |   是 (√)  |  12 >= 1 (√) -> 第1种!
  2    |      6      |   是 (√)  |   6 >= 2 (√) -> 第2种!
  3    |      4      |   是 (√)  |   4 >= 3 (√) -> 第3种!
  4    |      3      |   是 (√)  |   3 >= 4 (X) -> 停！

教练启发：“你有没有发现，当宽变成 4，长变成 3 的时候，长反而比宽小了？这和题目里说的‘长 $\ge$ 宽’矛盾了。而且 $4 \times 3$ 和前面找过的 $3 \times 4$ 是同一个长方形。所以，我们是不是到某个地方就可以直接停止了？”

第二步：寻找临界点（时间复杂度优化）

教练提问：“在什么情况下，‘宽’会等于‘长’呢？” 学生思考后应该能得出：“长方形变成正方形的时候，也就是 宽 $\times$ 宽 = 面积。” 教练总结：“没错！也就是说，宽的极限就是面积的平方根（$\sqrt{A}$）。只要 宽 $\times$ 宽 $\le A$，我们就继续找；一旦 宽 $\times$ 宽 $> A$，后面找的就全都是重复的了。”

第三步：复杂度的思考

• 空间复杂度：
  • 我们只需要存几个变量：面积 $A$、当前的宽 $W$、计数器 $C$。
  • 分析结果：不论 $A$ 有多大，变量数量不变，所以空间复杂度是 $O(1)$，非常优秀。
• 时间复杂度（不优化的暴力法）：
  • 如果我们让宽 $W$ 从 $1$ 一直循环到 $A$。
  • 分析结果：循环执行 $A$ 次。时间复杂度 $O(A)$。
  • 结合数据范围：题目中 $A \le 1000$，1000 次循环对计算机（每秒运行 $10^8$ 次）来说连 1 毫秒都不到，完全能过（AC）。
• 时间复杂度（优化后）：
  • 如果我们让宽 $W$ 的循环条件变成 $W \times W \le A$。
  • 分析结果：循环只需要执行 $\sqrt{A}$ 次。时间复杂度 $O(\sqrt{A})$。
  • 结合数据范围：当 $A = 1000$ 时，$\sqrt{1000} \approx 31.6$。计算机只需要循环 31 次！这是一种质的飞跃，如果以后题目把 $A$ 放大到 $10^{12}$，第一种方法会超时（TLE），而这种优化方法依然能瞬间算完！

4. 读题时的“题眼”（关键词）提取技巧

做这类题目，读题时要在心里（或用笔）把这几个关键词圈出来：

1. “长和宽都是整数” —— 题眼： 意味着考的是因数分解/整除，用 % 运算解决。
2. “长大于等于宽” / “长宽相等认为是同一种” —— 题眼： 意味着去重和规定顺序。这是缩小搜索范围的关键，暗示你只要遍历到 $\sqrt{A}$ 就可以了。
3. “正方形是长方形的特例” —— 题眼： 提醒你判断条件要包含等于的情况（比如判断整除时，边界条件是 $W \times W \le A$，这里的等号不能漏）。
4. “$2 \le A \le 1000$” —— 题眼： 数据范围决定算法。1000 很小，$O(N)$ 暴力枚举也能过；但在奥赛中，养成直接思考 $O(\sqrt{N})$ 优化的习惯，能让你在未来面对更难的题目时游刃有余。

现在，顺着草稿纸上的思路，去把代码实现出来吧！如果有卡壳的地方，随时来找我。