C++ 实现版本

下面是针对这个问题的 C++ 完整实现，核心贪心逻辑和之前的 Python 版本一致，但适配了 C++ 的语法特性（数组、排序、输入输出等）：

#include <iostream>
#include <vector>
#include <algorithm> // 用于sort函数

using namespace std;

int main() {
    int n;
    // 读取选手数量
    cin >> n;
    
    // 定义并读取本班和对方选手的实力数组
    vector<int> our_team(n);
    vector<int> opp_team(n);
    
    for (int i = 0; i < n; ++i) {
        cin >> our_team[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> opp_team[i];
    }
    
    // 对两队实力进行升序排序（贪心策略的基础）
    sort(our_team.begin(), our_team.end());
    sort(opp_team.begin(), opp_team.end());
    
    // 初始化指针和金币数
    int our_left = 0;        // 本班最弱选手指针
    int our_right = n - 1;   // 本班最强选手指针
    int opp_left = 0;        // 对方最弱选手指针
    int opp_right = n - 1;   // 对方最强选手指针
    int gold = 0;            // 总金币数
    
    // 核心贪心配对逻辑
    while (our_left <= our_right) {
        // 情况1：本班当前最强能赢对方最强 → 赢2金币
        if (our_team[our_right] > opp_team[opp_right]) {
            gold += 2;
            our_right--;
            opp_right--;
        }
        // 情况2：本班当前最强打不过对方最强
        else {
            // 子情况1：本班最弱能赢对方最弱 → 赢2金币
            if (our_team[our_left] > opp_team[opp_left]) {
                gold += 2;
                our_left++;
                opp_left++;
            }
            // 子情况2：本班最弱也打不过对方最弱 → 用本班最弱消耗对方最强
            else {
                // 若本班最弱 < 对方最强 → 输2金币；相等则无损失
                if (our_team[our_left] < opp_team[opp_right]) {
                    gold -= 2;
                }
                our_left++;
                opp_right--;
            }
        }
    }
    
    // 输出最终金币数
    cout << gold << endl;
    
    return 0;
}

代码关键说明

1. 输入与容器选择：

   • 使用 vector<int> 存储选手实力（相比普通数组更灵活，无需手动管理内存）；
   • 通过 cin 读取输入，符合 C++ 标准输入习惯。

2. 排序操作：

   • 调用 <algorithm> 头文件中的 sort 函数，对两个数组进行升序排序（默认升序），这是贪心策略的前提——有序数组才能高效实现“最优配对”。

3. 指针与循环逻辑：

   • 四个指针分别指向两队的“当前最弱/最强”选手，通过移动指针实现“一对一配对”；
   • 循环终止条件 our_left <= our_right 确保所有选手都参与且仅参与一次比赛。

4. 贪心策略落地：

   • 优先用“本班最强”赢“对方最强”（最大化单次收益）；
   • 次优先用“本班最弱”赢“对方最弱”（避免浪费强选手）；
   • 最后用“本班最弱”消耗“对方最强”（最小化强选手的损失）。

测试用例验证

测试用例1： 输入：

3  
9 5 7  
8 6 4  

排序后：

• 本班：[5,7,9]，对方：[4,6,8] 执行过程：

1. 9>8 → 金币+2（gold=2），our_right=1，opp_right=1；
2. 7>6 → 金币+2（gold=4），our_right=0，opp_right=0；
3. 5>4 → 金币+2（gold=6），our_left=1，循环结束； 输出：6（与样例一致）。

测试用例2： 输入：

5  
1 3 5 7 9  
2 4 6 8 10  

排序后：

• 本班：[1,3,5,7,9]，对方：[2,4,6,8,10] 执行过程：

1. 9<10 → 看本班最弱1是否>对方最弱2？否 → 用1消耗10（1<10，金币-2，gold=-2），our_left=1，opp_right=3；
2. 9>8 → 金币+2（gold=0），our_right=3，opp_right=2；
3. 7>6 → 金币+2（gold=2），our_right=2，opp_right=1；
4. 5>4 → 金币+2（gold=4），our_right=1，opp_right=0；
5. 3>2 → 金币+2（gold=6），our_right=0，opp_right=-1； 循环结束，输出：6（与样例一致）。

总结

1. 核心思路：通过排序+双指针贪心策略，优先赢取高价值对决，其次最小化损失，最终最大化总金币；
2. 时间复杂度：O(N log N)（主要来自排序，双指针遍历为O(N)），能高效处理N≤2000的场景；
3. 关键逻辑：优先用本班最强赢对方最强 → 其次用本班最弱赢对方最弱 → 最后用本班最弱消耗对方最强。