问题分析

本题核心是枚举所有满足 i<j 的数对，并统计其中符号相同的数对数量。题目明确要求使用嵌套循环枚举，因此无需优化算法（n≤1000，嵌套循环时间复杂度 O(n²)=10⁶，完全符合时间限制）。

关键要点：

1. 数对条件：i < j 且 a[i] 和 a[j] 符号相同；
2. 符号分类：
   • 正数：a > 0；
   • 负数：a < 0；
   • 零：a = 0；
3. 嵌套循环逻辑：外层循环遍历 i（0~n-2），内层循环遍历 j（i+1~n-1），逐个判断条件并计数。

完整C++代码实现

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    
    vector<int> nums(n);
    for (int i = 0; i < n; ++i) {
        cin >> nums[i];
    }
    
    int count = 0; // 统计符合条件的数对数量
    
    // 嵌套循环枚举所有i < j的数对
    for (int i = 0; i < n; ++i) { // 外层循环：第一个数的索引i
        for (int j = i + 1; j < n; ++j) { // 内层循环：第二个数的索引j（j > i）
            // 判断两个数的符号是否相同
            bool same_sign = false;
            // 情况1：都是正数
            if (nums[i] > 0 && nums[j] > 0) {
                same_sign = true;
            }
            // 情况2：都是负数
            else if (nums[i] < 0 && nums[j] < 0) {
                same_sign = true;
            }
            // 情况3：都是零
            else if (nums[i] == 0 && nums[j] == 0) {
                same_sign = true;
            }
            
            // 符号相同则计数+1
            if (same_sign) {
                count++;
            }
        }
    }
    
    cout << count << endl;
    
    return 0;
}

代码详细解释

1. 输入处理

int n;
cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; ++i) {
    cin >> nums[i];
}

• 读取序列长度 n，并用 vector<int> 存储序列中的数字，索引从 0 开始（符合题目中 0≤i<j<n 的要求）。

2. 嵌套循环枚举数对

for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
        // 判断符号是否相同并计数
    }
}

• 外层循环 i：遍历第一个数的索引（0 ~ n-1）；
• 内层循环 j：遍历第二个数的索引，且 j 必须大于 i（保证 i<j），范围是 i+1 ~ n-1；
• 这种遍历方式能覆盖所有 i<j 的数对，且不会重复（如 (i,j) 和 (j,i) 不会被重复统计）。

3. 符号相同判断

bool same_sign = false;
if (nums[i] > 0 && nums[j] > 0) {
    same_sign = true;
}
else if (nums[i] < 0 && nums[j] < 0) {
    same_sign = true;
}
else if (nums[i] == 0 && nums[j] == 0) {
    same_sign = true;
}

• 分三种情况判断符号相同：
  1. 两个数都大于 0（正数）；
  2. 两个数都小于 0（负数）；
  3. 两个数都等于 0；
• 只要满足其中一种情况，same_sign 设为 true，否则为 false。

4. 计数与输出

if (same_sign) {
    count++;
}
// 循环结束后输出结果
cout << count << endl;

• 每找到一对符号相同的数对，计数器 count 加 1；
• 最终输出计数器值，即符合条件的数对总数。

测试用例验证

样例1

输入：

5
1 -2 3 -4 5

序列：[1, -2, 3, -4, 5] 枚举所有 i<j 的数对并判断： | i | j | 数对 | 符号是否相同 | 计数 | |---|---|------|--------------|------| | 0 | 1 | (1,-2) | 否 | 0 | | 0 | 2 | (1,3) | 是 | 1 | | 0 | 3 | (1,-4) | 否 | 1 | | 0 | 4 | (1,5) | 是 | 2 | | 1 | 2 | (-2,3) | 否 | 2 | | 1 | 3 | (-2,-4) | 是 | 3 | | 1 | 4 | (-2,5) | 否 | 3 | | 2 | 3 | (3,-4) | 否 | 3 | | 2 | 4 | (3,5) | 是 | 4 | | 3 | 4 | (-4,5) | 否 | 4 | 最终输出 4，与样例一致。

样例2

输入：

4
-1 -2 3 4

序列：[-1, -2, 3, 4] 符合条件的数对：

• (0,1)：(-1,-2) → 符号相同；
• (2,3)：(3,4) → 符号相同； 总计 2 个，输出 2，与样例一致。

边界情况测试

• n=1：输入 1 5 → 无 i<j 的数对，输出 0；
• 全零序列：输入 3 0 0 0 → 数对 (0,1)、(0,2)、(1,2) 均符合，输出 3；
• 正负交替：输入 4 1 -1 1 -1 → 符合条件的数对：(0,2)、(1,3)，输出 2。

总结

1. 核心逻辑：严格按照题目要求使用嵌套循环枚举所有 i<j 的数对，逐对判断符号是否相同并计数；
2. 关键细节：
   • 内层循环 j 从 i+1 开始，保证 i<j；
   • 符号判断需覆盖“正数、负数、零”三种情况；
3. 效率分析：n≤1000 时，嵌套循环最多执行 1000×999/2 ≈ 5×10⁵ 次，远低于时间限制（1000ms 可执行约 10⁸ 次操作），效率完全满足要求。

不是老弟，想要题解，给我自己写🤣

g

what are you doing here?

d