华为OD机试真题——求最多可以派出多少支队伍（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现

2025 A卷 100分 题型

本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式；

并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；

本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《求最多可以派出多少支队伍》：

---

文章快捷目录

题目描述及说明

Java

python

JavaScript

C

GO

更多内容

---

题目名称：求最多可以派出多少支队伍

---

1. 知识点：贪心算法、双指针、排序
2. 时间限制：1秒
3. 空间限制：256MB
4. 限定语言：不限

---

题目描述

用数组代表每个人的能力，一个比赛活动要求参赛团队的最低能力值为N。每个团队可以由1人或2人组成，且1个人只能参加1个团队。请计算出最多可以派出多少支符合要求的团队？

输入描述：

• 第一行为总人数，范围[1,500000]。
• 第二行为每个人的能力值数组，元素取值范围[1,500000]，数组大小与总人数一致。
• 第三行为团队要求的最低能力值N，范围[1,500000]。

输出描述：

• 最多可以派出的团队数量。

示例：
输入：

5  
3 1 5 7 9  
8  

输出：

3  

说明：

• 3和5组成一队（3+5≥8），1和7组成一队（1+7≥8），9单独一队（9≥8），共3队。

---

Java

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

import java.util.Arrays;
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int total = scanner.nextInt();int[] abilities = new int[total];for (int i = 0; i < total; i++) {abilities[i] = scanner.nextInt();}int N = scanner.nextInt();Arrays.sort(abilities); // 将能力值排序，便于双指针操作int left = 0;          // 左指针，指向当前最小未处理的能力值int right = total - 1; // 右指针，指向当前最大未处理的能力值int count = 0;         // 统计符合要求的团队数量while (left <= right) { // 当还有人未处理时循环if (abilities[right] >= N) { // 右指针的人能力值达标，单独成队count++;right--; // 处理下一个更大的能力值（指针左移）} else { // 右指针的人无法单独成队，尝试与左指针的人组队if (left < right && abilities[left] + abilities[right] >= N) { // 左右指针不同且组合达标count++;left++; // 左指针右移，处理下一个更小的能力值right--; // 右指针左移，处理下一个更大的能力值} else { // 无法组队，左指针右移（当前右指针的人无法配对，只能放弃）left++;}}}System.out.println(count);}
}

---

代码详解

1. 输入处理：读取总人数、能力数组和最低要求N。
2. 排序：将数组排序，便于双指针从两端向中间处理。
3. 双指针初始化：left指向最小元素，right指向最大元素。
4. 循环处理：
   • 右指针单独成队：若当前右指针的人能力≥N，直接成队。
   • 尝试组队：若左右指针非同一人且能力之和≥N，组队。
   • 无法处理：左指针右移，放弃当前右指针的人。
5. 输出结果：统计所有可能的队伍数量。

---

示例测试

1. 示例输入1：

   5
   3 1 5 7 9
   8
   

   输出：3
   说明：3和5组队，1和7组队，9单独成队。

2. 示例输入2：

   2
   4 5
   8
   

   输出：1
   说明：4和5组队。

3. 示例输入3：

   3
   3 3 3
   5
   

   输出：1
   说明：其中两人组队（3+3≥5），剩下一人无法成队。

---

综合分析

1. 时间复杂度：O(n log n)，排序耗时O(n log n)，双指针遍历O(n)。
2. 空间复杂度：O(1)，仅使用常量额外空间。
3. 正确性：
   • 贪心策略确保每次尽可能组成最多的队伍。
   • 排序和双指针处理所有可能的组合。
4. 适用性：
   • 处理大规模数据高效（如50万人）。
   • 逻辑清晰，避免复杂递归或动态规划。
5. 为何最优：
   • 贪心策略优先处理能力大的人，最大化利用高能力值。
   • 双指针保证线性时间复杂度，避免重复计算。

---

python

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

def max_teams():import sys# 读取输入数据total = int(sys.stdin.readline())          # 总人数abilities = list(map(int, sys.stdin.readline().split()))  # 能力数组N = int(sys.stdin.readline())              # 团队最低能力要求# 将能力数组从小到大排序（排序后：左指针指向最小，右指针指向最大）abilities.sort()left = 0                # 左指针初始指向最小值right = total - 1       # 右指针初始指向最大值count = 0               # 统计符合要求的团队数量# 双指针贪心算法while left <= right:# 如果当前右指针的人能力值 >= N，单独成队if abilities[right] >= N:count += 1right -= 1      # 处理下一个更大的能力值（右指针左移）else:# 尝试与左指针的人组队if left < right and (abilities[left] + abilities[right] >= N):count += 1left += 1   # 左指针右移（处理更小的能力值）right -= 1  # 右指针左移（处理更大的能力值）else:# 无法组队，丢弃当前左指针的人（因为它无法与任何更大的值组队）left += 1print(count)# 示例测试
if __name__ == "__main__":# 示例1：输入5\n3 1 5 7 9\n8 → 输出3# 示例2：输入2\n4 5\n8 → 输出1# 示例3：输入3\n3 3 3\n5 → 输出1max_teams()

---

代码详解

1. 输入处理：

   total = int(sys.stdin.readline())          # 读取总人数
   abilities = list(map(int, sys.stdin.readline().split()))  # 读取能力数组
   N = int(sys.stdin.readline())              # 读取最低要求N
   

   • 使用 sys.stdin.readline() 逐行读取输入，避免缓冲区问题。

2. 排序能力数组：

   abilities.sort()  # 排序后数组顺序为从小到大
   

   • 排序后左指针指向最小值，右指针指向最大值。

3. 双指针初始化：

   left = 0                # 指向最小值的索引
   right = total - 1       # 指向最大值的索引
   count = 0               # 统计结果
   

   • 左指针从最小能力开始，右指针从最大能力开始。

4. 双指针贪心算法：

   while left <= right:if abilities[right] >= N:  # 右指针的人单独成队count += 1right -= 1else:if left < right and (abilities[left] + abilities[right] >= N):count += 1left += 1right -= 1else:left += 1
   

   • 右指针单独成队：如果当前最大值满足要求，直接计数。
   • 组队尝试：若左右指针非同一人且能力之和达标，组队并移动双指针。
   • 无法组队：左指针右移（放弃当前左值，因为它无法与更大的值组队）。

5. 输出结果：

   print(count)
   

---

示例测试

1. 示例1输入：

   5
   3 1 5 7 9
   8
   

   处理过程：

   • 排序后数组：[1, 3, 5, 7, 9]
   • 右指针指向9（≥8）→ 单独成队，count=1，右指针→7
   • 右指针7不达标，尝试与左指针1组队（1+7=8）→ 成队，count=2，左右指针→3和5
   • 右指针5不达标，尝试与左指针3组队（3+5=8）→ 成队，count=3
     输出：3

2. 示例2输入：

   2
   4 5
   8
   

   处理过程：

   • 排序后数组：[4, 5]
   • 右指针5不达标，尝试与左指针4组队（4+5=9≥8）→ 成队，count=1
     输出：1

3. 示例3输入：

   3
   3 3 3
   5
   

   处理过程：

   • 排序后数组：[3, 3, 3]
   • 右指针3不达标，尝试与左指针3组队（3+3=6≥5）→ 成队，count=1
   • 剩余右指针3不达标，无法组队
     输出：1

---

综合分析

1. 时间复杂度：O(n log n)

   • 排序时间复杂度为O(n log n)，双指针遍历O(n)。

2. 空间复杂度：O(n)

   • 存储能力数组需要O(n)空间。

3. 正确性：

   • 贪心策略确保每次优先用最小的代价（最小左值）满足组队条件。
   • 双指针从两端向中间逼近，覆盖所有可能的组队情况。

4. 适用性：

   • 能处理最大50万的数据规模，满足题目要求。

5. 为什么这是最佳实现？

   • 贪心选择最优：总让剩余的最大值优先被使用，最大化后续组队可能性。
   • 双指针高效：线性遍历，避免暴力枚举所有组合（O(n²)）。
   • 代码简洁：逻辑清晰，无冗余操作。

---

JavaScript

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

function maxTeams(abilities, N) {// 将能力数组从小到大排序（确保数值正确排序）abilities.sort((a, b) => a - b);let left = 0;                // 左指针，指向最小能力值的索引let right = abilities.length - 1; // 右指针，指向最大能力值的索引let count = 0;               // 统计符合要求的团队数量// 双指针贪心算法while (left <= right) {// 如果当前右指针的人能力值 >= N，单独成队if (abilities[right] >= N) {count++;right--; // 处理下一个更大的能力值（右指针左移）} else {// 尝试与左指针的人组队if (left < right && abilities[left] + abilities[right] >= N) {count++;left++;  // 左指针右移（处理更小的能力值）right--; // 右指针左移（处理更大的能力值）} else {// 无法组队，丢弃当前左指针的人（因为它无法与任何更大的值组队）left++;}}}return count;
}// 示例测试
console.log(maxTeams([3, 1, 5, 7, 9], 8));    // 输出3
console.log(maxTeams([4, 5], 8));            // 输出1
console.log(maxTeams([3, 3, 3], 5));        // 输出1

---

代码详解

1. 排序能力数组：

   abilities.sort((a, b) => a - b); // 从小到大排序
   

   • JavaScript 的 sort 默认按字符串排序，需传入比较函数确保数值正确排序。

2. 双指针初始化：

   let left = 0;                // 左指针初始指向最小值的索引
   let right = abilities.length - 1; // 右指针初始指向最大值的索引
   

   • left 从数组头部开始，right 从尾部开始。

3. 循环处理双指针：

   while (left <= right) {// 右指针的人能力值达标，单独成队if (abilities[right] >= N) {count++;right--;} else {// 尝试与左指针的人组队if (left < right && abilities[left] + abilities[right] >= N) {count++;left++;right--;} else {left++; // 无法组队，左指针右移}}
   }
   

   • 右指针单独成队：若当前最大值满足要求，直接计数。
   • 组队尝试：若左右指针非同一人且能力之和达标，则组队。
   • 无法组队：左指针右移（放弃当前左值，尝试更小的左值）。

4. 返回结果：

   return count;
   

---

示例测试

1. 示例1：[3, 1, 5, 7, 9]，N=8

   • 排序后：[1, 3, 5, 7, 9]
   • 9单独成队 → count=1
   • 7与1组队 → count=2
   • 5与3组队 → count=3
     输出：3

2. 示例2：[4, 5]，N=8

   • 排序后：[4, 5]
   • 5与4组队 → count=1
     输出：1

3. 示例3：[3, 3, 3]，N=5

   • 排序后：[3, 3, 3]
   • 两个3组队 → count=1
     输出：1

---

综合分析

1. 时间复杂度：O(n log n)

   • 排序耗时 O(n log n)，双指针遍历 O(n)，总复杂度由排序主导。

2. 空间复杂度：O(1)

   • 仅使用常数级变量（left、right、count）。

3. 正确性：

   • 贪心策略正确性：每次优先处理最大值，确保后续可能的组队机会最大化。
   • 双指针覆盖所有情况：从两端向中间逼近，确保所有可能组合被检查。

4. 适用性：

   • 处理大规模数据：50万级别的数据可在1秒内完成（排序+遍历）。
   • 逻辑清晰：代码简洁，无复杂递归或动态规划。

5. 为什么这是最佳实现？

   • 贪心最优性：每次选择当前最优解（最大能力优先使用）。
   • 高效性：双指针线性遍历，避免暴力枚举所有组合（复杂度从O(n²)降到O(n)）。
   • 低空间开销：无需额外存储空间，仅需基本变量。

---

C++

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

#include <iostream>
#include <vector>
#include <algorithm> // 用于排序using namespace std;int maxTeams(vector<int>& abilities, int N) {sort(abilities.begin(), abilities.end()); // 将能力值从小到大排序int left = 0;                            // 左指针，指向最小能力值的索引int right = abilities.size() - 1;         // 右指针，指向最大能力值的索引int count = 0;                            // 统计符合要求的团队数量// 双指针贪心算法while (left <= right) {// 如果当前右指针的人能力值 >= N，单独成队if (abilities[right] >= N) {count++;right--; // 处理下一个更大的能力值（右指针左移）} else {// 尝试与左指针的人组队if (left < right && (abilities[left] + abilities[right] >= N)) {count++;left++;   // 左指针右移（处理更小的能力值）right--;  // 右指针左移（处理更大的能力值）} else {// 无法组队，丢弃当前左指针的人（因为它无法与任何更大的值组队）left++;}}}return count;
}int main() {// 示例测试vector<int> example1 = {3, 1, 5, 7, 9};cout << maxTeams(example1, 8) << endl;   // 输出3vector<int> example2 = {4, 5};cout << maxTeams(example2, 8) << endl;   // 输出1vector<int> example3 = {3, 3, 3};cout << maxTeams(example3, 5) << endl;   // 输出1return 0;
}

---

代码详解

1. 输入排序：

   sort(abilities.begin(), abilities.end()); // 将能力值从小到大排序
   

   • 排序后左指针指向最小值，右指针指向最大值，便于后续双指针操作。

2. 双指针初始化：

   int left = 0;                            // 左指针初始指向最小值
   int right = abilities.size() - 1;        // 右指针初始指向最大值
   

   • left 从数组头部开始，right 从尾部开始。

3. 循环处理双指针：

   while (left <= right) {if (abilities[right] >= N) {        // 右指针的人能力值达标，单独成队count++;right--;} else {if (left < right && (abilities[left] + abilities[right] >= N)) {count++;left++;   // 左指针右移（处理更小的能力值）right--;  // 右指针左移（处理更大的能力值）} else {left++;   // 无法组队，左指针右移}}
   }
   

   • 右指针单独成队：若当前最大值满足要求，直接计数。
   • 组队尝试：若左右指针非同一人且能力之和达标，则组队。
   • 无法组队：左指针右移（放弃当前左值，尝试更小的左值）。

4. 返回结果：

   return count; // 返回总团队数
   

---

示例测试

1. 示例1输入：{3, 1, 5, 7, 9}, N=8

   • 排序后数组：[1, 3, 5, 7, 9]
   • 9单独成队 → count=1
   • 7与1组队 → count=2
   • 5与3组队 → count=3
     输出：3

2. 示例2输入：{4, 5}, N=8

   • 排序后数组：[4, 5]
   • 5与4组队 → count=1
     输出：1

3. 示例3输入：{3, 3, 3}, N=5

   • 排序后数组：[3, 3, 3]
   • 两个3组队 → count=1
     输出：1

---

综合分析

1. 时间复杂度：O(n log n)

   • 排序时间复杂度为 O(n log n)，双指针遍历 O(n)，总复杂度由排序主导。

2. 空间复杂度：O(1)

   • 仅使用常数级变量（left、right、count），无额外空间开销。

3. 正确性：

   • 贪心策略正确性：优先处理最大值，确保后续可能的组队机会最大化。
   • 双指针覆盖所有情况：从两端向中间逼近，确保所有可能组合被检查。

4. 适用性：

   • 处理大规模数据：50万级别的数据可在1秒内完成（排序+遍历）。
   • 逻辑清晰：代码简洁，无复杂递归或动态规划。

5. 为什么这是最佳实现？

   • 贪心最优性：每次选择当前最优解（最大能力优先使用）。
   • 高效性：双指针线性遍历，避免暴力枚举所有组合（复杂度从O(n²)降到O(n)）。
   • 低空间开销：无需额外存储空间，仅需基本变量。

---

C

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

#include <stdio.h>
#include <stdlib.h>// 比较函数用于升序排序
int compare(const void *a, const void *b) {return (*(int *)a - *(int *)b);
}int max_teams(int *abilities, int size, int N) {qsort(abilities, size, sizeof(int), compare); // 将能力值从小到大排序int left = 0;                // 左指针，指向最小能力值的索引int right = size - 1;        // 右指针，指向最大能力值的索引int count = 0;              // 统计符合要求的团队数量// 双指针贪心算法while (left <= right) {// 如果当前右指针的人能力值 >= N，单独成队if (abilities[right] >= N) {count++;right--;} else {// 尝试与左指针的人组队if (left < right && (abilities[left] + abilities[right] >= N)) {count++;left++;right--;} else {// 无法组队，左指针右移left++;}}}return count;
}int main() {int total, N;scanf("%d", &total); // 读取总人数// 动态分配数组内存int *abilities = (int *)malloc(total * sizeof(int));for (int i = 0; i < total; i++) {scanf("%d", &abilities[i]); // 读取能力数组}scanf("%d", &N); // 读取最低要求Nprintf("%d\n", max_teams(abilities, total, N));free(abilities); // 释放动态分配的内存return 0;
}

---

代码详解

1. 比较函数：

   int compare(const void *a, const void *b) {return (*(int *)a - *(int *)b); // 升序排序
   }
   

   • 用于 qsort 的排序函数，确保能力值从小到大排列。

2. 排序与双指针初始化：

   qsort(abilities, size, sizeof(int), compare);
   int left = 0, right = size - 1, count = 0;
   

   • qsort 对数组排序，双指针初始化指向数组两端。

3. 双指针处理逻辑：

   while (left <= right) {if (abilities[right] >= N) { // 右指针单独成队count++;right--;} else {if (left < right && (abilities[left] + abilities[right] >= N)) { // 组队count++;left++;right--;} else { // 无法组队，左移left++;}}
   }
   

   • 右指针单独成队：若当前最大值满足要求，直接计数。
   • 组队尝试：若左右指针非同一人且能力之和达标，则组队。
   • 无法组队：左指针右移（放弃当前左值）。

4. 输入处理与内存管理：

   int *abilities = (int *)malloc(total * sizeof(int)); // 动态分配数组
   free(abilities); // 释放内存
   

   • 动态分配数组内存避免栈溢出，使用后释放内存防止泄漏。

---

示例测试

1. 输入1：

   5
   3 1 5 7 9
   8
   

   排序后数组：[1, 3, 5, 7, 9]
   处理过程：

   • 9 单独成队 → count=1
   • 7 和 1 组队 → count=2
   • 5 和 3 组队 → count=3
     输出：3

2. 输入2：

   2
   4 5
   8
   

   排序后数组：[4, 5]
   处理过程：

   • 5 和 4 组队 → count=1
     输出：1

3. 输入3：

   3
   3 3 3
   5
   

   排序后数组：[3, 3, 3]
   处理过程：

   • 两个 3 组队 → count=1
     输出：1

---

综合分析

1. 时间复杂度：O(n log n)

   • qsort 排序时间复杂度为 O(n log n)，双指针遍历 O(n)，总复杂度由排序主导。

2. 空间复杂度：O(1)

   • 除输入数组外，仅使用常数级变量（left、right、count）。

3. 正确性：

   • 贪心策略：优先处理最大值，确保后续可能的组队机会最大化。
   • 双指针覆盖所有情况：从两端向中间逼近，确保所有可能组合被检查。

4. 适用性：

   • 处理大规模数据：50万级别的数据可在1秒内完成排序和遍历。
   • 内存安全：动态分配内存避免栈溢出，释放防止内存泄漏。

5. 为什么这是最佳实现？

   • 贪心最优性：每次选择当前最优解（最大能力优先使用）。
   • 高效性：双指针线性遍历，避免暴力枚举所有组合（复杂度从 O(n²) 降到 O(n)）。
   • 低空间开销：无需额外存储空间，仅需基本变量。

---

GO

问题分析

我们需要从一组人中选出尽可能多的团队，每个团队可以由1人或2人组成，且能力值之和需达到最低要求N。目标是找到最大的团队数量。

---

解题思路

1. 排序数组：将能力值从小到大排序，便于双指针操作。
2. 贪心策略：使用双指针，优先让能力大的人单独成队，若不能则尝试与能力小的人组队。
3. 双指针操作：
   • 右指针从最大能力开始，若单独满足要求则成队。
   • 否则尝试与左指针的人组队，若满足则成队，否则左移找更小能力的人。

---

代码实现

package mainimport ("bufio""fmt""os""sort""strconv""strings"
)func maxTeams(abilities []int, N int) int {// 将能力数组从小到大排序sort.Ints(abilities)left := 0          // 左指针，指向最小能力值的索引right := len(abilities) - 1 // 右指针，指向最大能力值的索引count := 0         // 统计符合要求的团队数量// 双指针贪心算法for left <= right {if abilities[right] >= N { // 右指针的人能力值达标，单独成队count++right-- // 处理下一个更大的能力值（右指针左移）} else {// 尝试与左指针的人组队if left < right && (abilities[left]+abilities[right] >= N) {count++left++  // 左指针右移（处理更小的能力值）right-- // 右指针左移（处理更大的能力值）} else {// 无法组队，左指针右移（丢弃当前左指针的人）left++}}}return count
}func main() {// 读取输入scanner := bufio.NewScanner(os.Stdin)scanner.Scan()total, _ := strconv.Atoi(scanner.Text()) // 总人数scanner.Scan()// 读取能力数组字符串并转换为整数切片abilityStrs := strings.Fields(scanner.Text())abilities := make([]int, total)for i, s := range abilityStrs {abilities[i], _ = strconv.Atoi(s)}scanner.Scan()N, _ := strconv.Atoi(scanner.Text()) // 团队最低能力要求fmt.Println(maxTeams(abilities, N))
}

---

代码详解

1. 输入处理：

   scanner := bufio.NewScanner(os.Stdin)
   scanner.Scan()
   total, _ := strconv.Atoi(scanner.Text()) // 读取总人数
   

   • 使用 bufio.Scanner 逐行读取输入，确保处理大输入时的高效性。

2. 能力数组转换：

   abilityStrs := strings.Fields(scanner.Text()) // 分割字符串为切片
   abilities := make([]int, total)
   for i, s := range abilityStrs {abilities[i], _ = strconv.Atoi(s)
   }
   

   • 将输入的第二行（能力值字符串）分割并转换为整数切片。

3. 排序与双指针初始化：

   sort.Ints(abilities) // 对能力数组升序排序
   left := 0
   right := len(abilities) - 1
   

   • 排序后左指针指向最小值，右指针指向最大值。

4. 双指针处理逻辑：

   if abilities[right] >= N { // 右指针单独成队count++right--
   } else {if left < right && (abilities[left]+abilities[right] >= N) { // 组队count++left++right--} else { // 无法组队left++}
   }
   

   • 右指针单独成队：若当前最大值满足要求，直接计数。
   • 组队尝试：若左右指针非同一人且能力之和达标，则组队。
   • 无法组队：左指针右移（放弃当前左值）。

5. 输出结果：

   fmt.Println(maxTeams(abilities, N))
   

---

示例测试

1. 示例1输入：

   5
   3 1 5 7 9
   8
   

   处理过程：

   • 排序后数组：[1 3 5 7 9]
   • 9 单独成队 → count=1
   • 7 和 1 组队 → count=2
   • 5 和 3 组队 → count=3
     输出：3

2. 示例2输入：

   2
   4 5
   8
   

   处理过程：

   • 排序后数组：[4 5]
   • 5 和 4 组队 → count=1
     输出：1

3. 示例3输入：

   3
   3 3 3
   5
   

   处理过程：

   • 排序后数组：[3 3 3]
   • 两个 3 组队 → count=1
     输出：1

---

综合分析

1. 时间复杂度：O(n log n)

   • sort.Ints 排序时间复杂度为 O(n log n)，双指针遍历 O(n)。

2. 空间复杂度：O(n)

   • 存储能力数组需要 O(n) 空间。

3. 正确性：

   • 贪心策略正确性：每次优先处理最大值，确保后续可能的组队机会最大化。
   • 双指针覆盖所有情况：从两端向中间逼近，确保所有可能组合被检查。

4. 适用性：

   • 处理大规模数据：50万级别的数据可在1秒内完成排序和遍历。
   • 内存高效：切片动态分配内存，避免浪费。

5. 为什么这是最佳实现？

   • 贪心最优性：每次选择当前最优解（最大能力优先使用）。
   • 高效性：双指针线性遍历，避免暴力枚举所有组合（复杂度从 O(n²) 降到 O(n)）。
   • 代码简洁：利用Go语言的内置排序和切片特性，逻辑清晰。

---

更多内容：

https://www.kdocs.cn/l/cvk0eoGYucWA

本文发表于【纪元A梦】，关注我，获取更多实用教程/资源！