首页 › 试卷 › GESP编程能力等级认证 › GESP-C++四级 › 2025年12月CCF-GESP编程能力等级认证C++编程四级真题

2025年12月CCF-GESP编程能力等级认证C++编程四级真题 VIP

GESP-C++四级 共 27 题 2025 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

小杨想让指针 p 指向整数变量 x ,正确写法是( )

  • A
    int p = &x;
  • B
    int *p = x;
  • C
    int *p = &x;
  • D
    p = *x;
查看答案与解析
答案:C
解析: 定义一个指向整型的指针变量,需使用指针声明语法。获取变量的地址,需使用取地址运算符作用于该变量。将地址赋值给指针变量时,类型必须匹配。指针变量存储的是内存地址,而非值本身。通过间接访问运算符可操作指针所指向的对象。
2. 单选题

小杨写了如下的指针接力程序,程序执行完后变量 a 、 *p1 和 *p2 的值分别是( )。

int a = 5; 
int* p1 = &a; 
int* p2 = p1; 
*p2 = 10;
  • A 5 10 10
  • B 5 10 15
  • C 10 10 10
  • D 5 5 10
查看答案与解析
答案:C
解析: 声明整型变量a并初始化为5,定义指针p1指向a的地址,定义指针p2并将p1的值(即a的地址)赋给p2,通过解引用p2访问其所指向的内存位置,并将该位置的值修改为10。
3. 单选题

小杨用一个二维数组表示棋盘,其中 1 表示有棋子,0 表示没有棋子。他想知道第 2 行 第 3 列有没有棋子,

可采用的代码是:( )。

int a[3][4] = { 
    {1, 0, 1, 0}, 
    {0, 1, 0, 1}, 
    {1, 1, 0, 0} 
};
  • A
    cout << a[1, 2] << endl;
  • B
    cout << a[1][2] << endl;
  • C
    cout << a(1, 2) << endl;
  • D
    cout << a{1}{2} << endl;
查看答案与解析
答案:B
解析: 定义了一个二维数组a,行索引从0开始,列索引也从0开始。访问数组元素需使用方括号语法,先指定行下标,再指定列下标。要获取第2行第3列的值,应使用a[1][2],因为第2行对应下标1,第3列对应下标2。通过输出语句可显示该位置的值。数组初始化时按行主序依次赋值,每个内层花括号对应一行数据。
4. 单选题

执行完下面的代码后, *(p + 5) 和 arr[1][1] 的值分别是( )。

int arr[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}; 
int* p = &arr[0][0];
  • A 5 6
  • B 6 5
  • C 5 5
  • D 6 6
查看答案与解析
答案:D
解析: 首先确定二维数组arr在内存中的布局,其按行优先方式连续存储12个整型元素。指针p被初始化为指向arr[0][0]的地址,即数组首元素的地址。表达式*(p + 5)表示从p所指地址开始偏移5个整型大小的位置,并解引用该地址对应的值。由于p指向数组首地址,偏移5个元素后对应原数组中第6个元素(下标从0起始),即arr[1][1]所代表的逻辑位置。arr[1][1]直接通过二维数组下标访问第二行第二列元素。两个表达式均基于同一块连续内存的不同访问方式,计算时需将二维下标转换为一维偏移量或反之。
5. 单选题

执行完下面的代码后, sum 的值是( )。

int arr[2][3][2] = { 
    {{1,2}, {3,4}, {5,6}}, 
    {{7,8}, {9,10}, {11,12}} 
  }; 
int sum = 0; 
for(int i = 0; i < 2; i++) 
  for(int j = 0; j < 3; j++) 
    for(int k = 0; k < 2; k++) 
      if((i+j+k) % 2 == 0) 
        sum += arr[i][j][k];
  • A 36
  • B 39
  • C 78
  • D 30
查看答案与解析
答案:B
解析: 首先确定三维数组的结构:arr[2][3][2]表示两个二维数组,每个二维数组包含三行两列。初始化数据按顺序依次填充各元素。sum初始为0。循环部分未完整给出,但根据常见模式,i、j、k分别遍历第一维、第二维和第三维的索引。循环体内通常通过arr[i][j][k]访问每个元素,并将其值累加到sum中。遍历过程覆盖数组所有元素,每个元素被访问且仅被访问一次。累加操作在线性顺序下逐个进行,最终sum接收所有元素值的总和。
6. 单选题

执行完下面的代码后,输出是( )。

int a = 1; 

void test() { 
  int a = 2; 
    { 
      int a = 3; 
      a++; 
    } 
    a++; 
    cout << a << " "; 
} 

int main() { 
  test(); 
  cout << a; 
  return 0; 
}
  • A 3 1
  • B 4 1
  • C 3 2
  • D 4 2
查看答案与解析
答案:A
解析: 分析代码中变量a的作用域层次。函数test内声明的局部变量a会屏蔽外部同名全局变量。每个花括号块形成独立作用域,内部声明的a仅在该块内有效。执行a++操作时,修改的是当前作用域下最近声明的a。离开作用域后,之前的a恢复可见。函数调用结束后,main函数中使用的是全局变量a。输出顺序取决于cout语句的执行次序。
7. 单选题

执行完下面的代码后, a 、 b 和 c 的值分别是( )。

void byValue(int x) { x = 100; } 
void byRef(int& x) { x = 200; } 
void byPointer(int* x) { *x = 300; } 
int main() { 
    int a = 1, b = 2, c = 3; 
    byValue(a); 
    byRef(b); 
    byPointer(&c); 
    return 0; 
}
  • A 100 200 300
  • B 1 2 3
  • C 1 200 300
  • D 1 2 300
查看答案与解析
答案:C
解析: 分析函数参数传递方式:byValue函数接收值传递,形参修改不影响实参;byRef函数接收引用传递,形参绑定实参内存,修改直接影响实参;byPointer函数接收指针,通过解引用访问实参内存地址,修改影响实参。主函数中a传入byValue,其值不改变;b传入byRef,被直接修改;c的地址传入byPointer,通过指针解引用修改原值。各变量是否变化取决于参数传递机制对实参内存的访问与操作方式。
8. 单选题

运行如下代码会输出( )。

struct Point { 
    int x, y; 
}; 
struct Rectangle { 
    Point topLeft; 
    Point bottomRight; 
}; 
int main() { 
    Rectangle rect = {{10, 10}, {20, 20}}; 
    rect.topLeft.x = 5; 
    Point* p = &rect.bottomRight; 
    p->y = 5; 
    cout << rect.topLeft.x + rect.bottomRight.y; 
    return 0; 
}
  • A 10
  • B 30
  • C 15
  • D 20
查看答案与解析
答案:A
解析: 首先定义结构体Point包含两个整型成员x和y,结构体Rectangle包含两个Point类型的成员topLeft和bottomRight。在main函数中,声明Rectangle类型的变量rect并用嵌套初始化列表赋初值:topLeft的x和y被初始化为10,bottomRight的x和y被初始化为20。接着将rect.topLeft.x的值修改为5。然后定义指向Point类型的指针p,并将其指向rect.bottomRight的地址。通过指针p访问其指向对象的y成员,并将其值修改为5。最后计算rect.topLeft.x与rect.bottomRight.y的和。
9. 单选题

给定函数 climbStairs(int n) 的定义如下,则 climbStairs(5) 的返回的值是( )。

int climbStairs(int n) { 
    if(n <= 2) return n; 
    int a = 1, b = 2; 
    for(int i = 3; i <= n; i++) { 
        int temp = a + b; 
        a = b; 
        b = temp; 
    } 
    return b; 
}
  • A 5
  • B 8
  • C 13
  • D 18
查看答案与解析
答案:B
解析: 分析函数定义,识别递归终止条件与递推关系。根据参数 n 的不同取值,判断函数调用自身时的分支路径。追踪每次递归调用传入的参数变化,统计所有到达终止条件的执行路径。结合递归返回值的组合方式,推导出最终返回结果的计算过程。
10. 单选题

对如下4个扑克牌进行排序,

struct Card { 
    int value; 
    char suit; // 花色 
}; 
Card cards[4] = {{5,'A'}, {3,'B'}, {5,'C'}, {3,'D'}};

使用某排序算法按value排序后,结果为: {3,'D'}, {3,'B'}, {5,'A'}, {5,'C'} ,则这个排序算法是稳定的吗?

  • A 稳定,因为相同 value 的元素相对顺序保持不变
  • B 不稳定,因为 {3,'D'} 出现在 {3,'B'} 之前
  • C 无法判断
  • D 稳定,因为结果是有序的
查看答案与解析
答案:B
解析: 比较排序前后相同value元素的相对位置。原数组中{3,'B'}在{3,'D'}之前,若排序后{3,'D'}在{3,'B'}之前,则相同value元素的先后顺序发生变化。稳定排序要求相同关键字的记录在排序后保持原有的相对顺序。通过检查相同value对应的不同suit元素在排序前后的次序是否发生交换,可判断算法是否满足稳定性条件。
11. 单选题

下面的函数 selectTopK() 实现从 n 个学生中选出前 k 名成绩最好的学生颁发奖学金(不需要对所有

学生完全排序,只需要找出前 k 名),则横线上应填写( )。

struct Student {
    string name;
    int score;
};

void selectTopK(Student students[], int n, int k) {
    for (int i = 0; i < k; i++) {
        int maxIdx = i;
        for (int j = i + 1; j < n; j++) { // 填空内容
            if (students[j].score > students[maxIdx].score) {
                maxIdx = j;
            }
        }
        if (maxIdx != i) {
            Student temp = students[i];
            students[i] = students[maxIdx];
            students[maxIdx] = temp;
        }
    }
}
  • A
    int j = 0; j < n; j++
  • B
    int j = i + 1; j < n; j++
  • C
    int j = i; j < n; j++
  • D
    int j = 1; j <= n; j++
查看答案与解析
答案:B
解析: 函数目标是选出前k名成绩最高的学生,采用选择排序的思想维护已处理部分的最大值位置。外层循环控制当前要放置最大值的位置i,内层循环需在剩余未排序部分查找最大值下标。初始假设位置i为最大值索引,内层循环应从i之后的元素开始比较,即j从i+1起始,遍历至数组末尾。每次比较若发现更大分数,则更新最大值索引。循环条件保证不越界且覆盖所有待比较元素。交换操作将当前轮最大值置于位置i,逐步构建前k个最大元素的有序段。
12. 单选题

某游戏的排行榜系统需要实时更新玩家分数。每次只有一个玩家的分数发生变化,排行榜已经是按分数降序排列的。现在需要将更新后的玩家调整到正确位置。下面的函数 updateRanking() 要实现上述功能,则两处横线上应分别填写( )。

#include <string>
using namespace std;

struct Player { 
  string name; 
  int score; 
 }; 

// 玩家索引playerIdx的分数刚刚更新,需要调整位置 
void updateRanking(Player players[], int size, int playerIdx) { 
  Player updatedPlayer = players[playerIdx]; 

  if (playerIdx > 0 && updatedPlayer.score > players[playerIdx - 1].score) { 
    int i = playerIdx; 
    while (i > 0 && updatedPlayer.score > players[i - 1].score) { // 第一空
      players[i] = players[i - 1]; 
      i--; 
    } 
    players[i] = updatedPlayer; 
  } 
  else if (playerIdx < size - 1 && updatedPlayer.score < players[playerIdx + 1].score) { 
    int i = playerIdx; 
    while (i < size - 1 && updatedPlayer.score < players[i + 1].score) { // 第二空
      players[i] = players[i + 1]; 
      i++; 
    } 
    players[i] = updatedPlayer; 
  } 
}
  • A
    i > 0 && updatedPlayer.score > players[i - 1].score 
    i < size - 1 && updatedPlayer.score < players[i + 1].score
  • B
    i < size - 1 && updatedPlayer.score < players[i + 1].score 
    i > 0 && updatedPlayer.score > players[i - 1].score
  • C
    i > 0 && updatedPlayer.score < players[i - 1].score 
    i < size - 1 && updatedPlayer.score < players[i + 1].score
  • D
    i > 0 && updatedPlayer.score < players[i - 1].score 
    i < size - 1 && updatedPlayer.score > players[i + 1].score
查看答案与解析
答案:A
解析: 首先确定玩家分数更新后可能的移动方向:若分数高于前一名玩家,则需向前移动;若低于后一名玩家,则需向后移动。在向前调整时,从当前索引开始,逐个比较前方元素,将分数较低的玩家向后移位,直到找到正确插入位置。在向后调整时,从当前索引开始,逐个比较后方元素,将分数较高的玩家向前移位,直到满足排序条件。循环条件需保证数组不越界,并持续判断待插入玩家与相邻玩家的分数关系,以决定是否继续移位。
13. 单选题

给定如下算法,其时间复杂度为( )。

bool f(int arr[], int n, int target) { 
    for (int i = 0; i < n; i++) { 
        int sum = 0; 
        for (int j = 0; j < n; j++) { 
            if (i & (1 << j)) { 
                sum += arr[j]; 
            } 
        } 
        if (sum == target) return true; 
    } 
    return false; 
}
  • A O(n)
  • B O(n^2)
  • C O(n^3)
  • D O(2^n)
查看答案与解析
答案:B
解析: 分析算法中循环结构的执行次数与输入规模n的关系。首先确定外层循环的迭代次数,再分析内层操作是否依赖于n或存在嵌套循环。若存在嵌套且内外层均与n线性相关,则总执行次数为n的多项式形式。若每层循环的迭代次数均与n成正比,则时间复杂度由最高次项决定。若无嵌套循环,仅单层线性遍历,则执行次数与n成正比。根据代码中循环层数和每层控制条件判断总体增长趋势。
14. 单选题

执行下面 C++ 程序,会输出( )。

int main() { 
    ofstream fout("test.txt"); 
    fout << "Happy" << endl; 
    fout << "New Year"; 
    fout.close(); 
    ifstream fin("test.txt"); 
    string s1, s2; 
    fin >> s1; 
    getline(fin, s2); 
    fin.close(); 
    cout << s1 << "|" << s2; 
    return 0; 
}
  • A
    Happy|New Year
  • B
    Happy| New Year
  • C
    HappyNew Year|
  • D
    Happy|
查看答案与解析
答案:D
解析: 程序首先创建一个输出文件流,将字符串写入test.txt文件。随后建立输入文件流读取同一文件。文件写入时未添加额外字符,读取操作从文件起始位置开始获取内容。字符串提取方式决定数据分割形式。输出流与输入流分别独立处理文本数据,中间无其他处理环节介入。整个过程依赖文件流的打开模式及读写函数的行为特性。
15. 单选题

执行下面C++代码,会输出( )。

int divide(int a, int b) { 
    if(b == 0) throw "Division by zero"; 
    return a / b; 
} 
int main() { 
    int result = 0; 
    try { 
        result = divide(10, 0); 
        cout << "A"; 
    } 
    catch(const char* msg) { 
        cout << "B"; 
        result = -1; 
    } 
    cout << result; 
    return 0; 
}
  • A A0
  • B B-1
  • C A10
  • D 程序崩溃
查看答案与解析
答案:B
解析: 分析函数divide的逻辑:当参数b为0时,抛出字符串异常;否则返回a/b的结果。main函数中定义result变量并初始化为0,随后进入try块调用divide(10, 0)。由于b为0,满足if条件,执行throw语句抛出异常。此时函数divide不返回值,控制流立即转移至最近的异常处理机制。后续cout语句位于try块内,但在throw执行后不会被执行。程序能否继续取决于是否存在匹配的catch块进行异常捕获与处理。若无相应catch块,异常未被捕获导致程序终止。

二、判断题

16. 判断题

小杨正在调试他的温度传感器程序,其中变量 x 保存当前温度。下面这段代码运行后,变量 x 的值变成

了 8 。

int x = 5; 
int *p = &x; 
*p = *p + 3;
  • A对
  • B错
查看答案与解析
答案:对
解析: 声明整型变量x并初始化为5;定义指针p指向x的地址;通过解引用操作*p访问p所指向的内存位置中的值;将该值与3进行加法运算后,结果重新存入该内存位置。
17. 判断题

一个结构体不能包含另一个结构体。

  • A对
  • B错
查看答案与解析
答案:错
解析: 分析结构体的定义和组成规则,明确结构体成员的合法类型范围;检查结构体是否允许以值或指针形式包含其他结构体实例;考察语言对复合类型的处理机制,确认结构体嵌套在语法和语义层面的可行性。
18. 判断题

在 C++ 中,定义如下二维数组: int a[3][4]; ,数组 a 在内存中是按行优先连续存放的,即 a[0][0] 、 a[0][1] 、 a[0][2] 、 a[0][3] 在内存中是连续的。

  • A对
  • B错
查看答案与解析
答案:对
解析: 分析二维数组在内存中的存储布局机制。确定数组元素的排列顺序是否遵循行优先原则。考察数组首地址与各元素地址之间的偏移关系。通过数组类型定义推导内存连续性特征。验证同一行内元素地址的递增规律。检查跨行时地址衔接方式。依据C++标准中关于多维数组存储的规定进行逻辑推演。
19. 判断题

执行下面程序后,变量 a 的值会变成 15 。

void add(int &x){ 
    x += 10; 
} 
int a = 5; 
add(a);
  • A对
  • B错
查看答案与解析
答案:对
解析: 分析函数参数传递方式,确认形参x为引用类型;跟踪实参a的内存地址是否与形参x绑定;执行函数体时,通过引用直接访问并修改原变量存储单元的值;观察赋值操作对初始数据的影响路径;检查函数调用前后变量a所在内存位置的数据变化过程。
20. 判断题

执行下面的C++代码,会输出 8 ,因为两个指针地址相差 8 个字节(假设 int 占 4 字节)。

int arr[5] = {1, 2, 3, 4, 5}; 
int* p1 = arr; 
int* p2 = arr + 2; 
cout << p2 - p1; // 输出结果
  • A对
  • B错
查看答案与解析
答案:错
解析: 计算两个指针之间的字节差需先确定它们指向的元素间隔。指针p1指向数组首元素,p2指向第三个元素,两者间隔两个int类型元素。指针算术运算中,地址差值为元素个数差乘以单个元素大小。输出结果由元素类型大小和索引差共同决定,与具体数值无关。地址差以字节为单位时,取决于数据类型的存储长度。
21. 判断题

考虑用如下递推方式计算斐波那契数列,时间复杂度是 O(n)。

int n = 10; 
int f[20]; 
f[0] = 0; 
f[1] = 1; 
for (int i = 2; i <= n; i++) 
    f[i] = f[i - 1] + f[i - 2];
  • A对
  • B错
查看答案与解析
答案:对
解析: 使用数组存储斐波那契数列前n项,通过循环从第2项开始逐项计算,每一项由前两项相加得到。循环执行n-1次,每次操作时间复杂度为O(1),整体时间复杂度为O(n)。数组下标与数列项一一对应,初始值f[0]=0、f[1]=1作为递推起点。循环变量i从2开始递增至n,每次更新f[i] = f[i-1] + f[i-2],直至完成所有项的计算。
22. 判断题

冒泡排序和插入排序都是稳定排序算法。

  • A对
  • B错
查看答案与解析
答案:对
解析: 分析两种排序算法在相等元素间的相对位置变化情况。冒泡排序通过相邻元素比较和交换实现排序,相等元素不会发生交换,相对位置保持不变。插入排序将未排序元素逐个插入已排序部分的适当位置,相等元素插入时不会越过原有相同值元素,相对位置得以保留。两种算法均不改变相等元素的原始先后顺序。
23. 判断题

下面这段代码实现了选择排序算法。

void sort(int a[], int n) { 
    for (int i = 1; i < n; i++) { 
        int x = a[i]; 
        int j = i - 1; 
        while (j >= 0 && a[j] > x) { 
            a[j + 1] = a[j]; 
            j--; 
        } 
        a[j + 1] = x; 
    } 
}
  • A对
  • B错
查看答案与解析
答案:错
解析: 分析代码结构,确认函数定义是否完整;检查外层循环的起始条件和终止条件是否符合选择排序逻辑;验证内层循环是否正确实现元素比较与位移;确认变量x的作用及其在插入过程中的位置;判断数组下标访问是否越界;核对每次迭代后数据状态是否满足局部有序;确认整个流程是否能覆盖所有元素并完成排序。
24. 判断题

下面代码可以正常编译并输出 10 。

#include <iostream> 
using namespace std; 
int calculate(int x, int y = 10); 
int main() { 
    cout << calculate(5); // 调用1 
    return 0; 
} 
int calculate(int x, int y) { 
    return x * y; 
} 
int calculate(int x) { // 重载函数 
    return x * 2; 
}
  • A对
  • B错
查看答案与解析
答案:错
解析: 分析代码结构,确认是否包含正确的头文件声明;检查函数声明与定义的语法是否匹配,参数默认值设置是否合法;验证main函数中是否存在对calculate函数的正确调用;确认输出语句是否使用了合适的流对象和操作符;检查程序是否具备完整的返回机制。
25. 判断题

执行下面代码会输出 100 。

int main() { 
    ofstream fout("data.txt"); 
    fout << 10 << " " << 20 << endl; 
    fout << 30 << " " << 40; 
    fout.close(); 
    ifstream fin("data.txt"); 
    int a, b, c, d; 
    fin >> a >> b >> c >> d; 
    fin.close(); 
    cout << a + b + c + d; 
    return 0; 
}
  • A对
  • B错
查看答案与解析
答案:对
解析: 分析代码执行流程:首先检查文件流对象的声明与初始化,确认ofstream是否正确打开文件;接着观察输出操作符的使用方向,判断数据是写入文件还是从文件读取;然后核查变量a、b、c、d的来源,确认是否存在对应的输入流操作;再检查fin.close()调用的对象是否为已定义的输入流;最后评估cout语句的后续操作,判断是否有数值被输出及该数值的生成机制。

三、简答题

26. 简答题

建造

时间限制:1.0 s

内存限制:512.0 MB

题目描述

小 A 有一张M行N列的地形图,其中第i 行第 列的数字aij代表坐标 ( i,j)) 的海拔高度。停机坪为一个3*3的区域且内部所有 9个点的最大高度和最小高度之差不超过H。 小 A 想请你计算出,在所有适合建造停机坪的区域中,区域内部9个点海拔之和最大是多少。

输入格式

第一行三个正整数M,N,H,含义如题面所示。之后M行,第i行包含N个整数ai1,ai2,...,aiN,代表坐标(i,j)的高度。数据保证总存在一个适合建造停机坪的区域。

输出格式

输出一行,代表最大的海拔之和。

输入样例

5 5 3
5 5 5 5 5
5 1 5 1 5
5 5 5 5 5
5 2 5 2 5
3 5 5 5 2

输出样例

40

数据范围

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; using namespace std; int a[1010][1010]; int main() {     int M, N, H;     cin &gt;&gt; M &gt;&gt; N &gt;&gt; H;     for (int i = 1; i &lt;= M; ++i) {         for (int j = 1; j &lt;= N; ++j) {             cin &gt;&gt; a[i][j];         }     }     int max_sum = 0;     for (int i = 1; i &lt;= M - 2; ++i) {         for (int j = 1; j &lt;= N - 2; ++j) {             int local_max = a[i][j], local_min = a[i][j], local_sum = 0;             for (int x = 0; x &lt; 3; ++x) {                 for (int y = 0; y &lt; 3; ++y) {                     int height = a[i + x][j + y];                     local_sum += height;                     if (height &gt; local_max)                         local_max = height;                     if (height &lt; local_min)                         local_min = height;                 }             }             if (local_max - local_min &lt;= H) {                 if (local_sum &gt; max_sum) {                     max_sum = local_sum;                 }             }         }     }     cout &lt;&lt; max_sum;     return 0; }</pre>
这道题暂未补解析。
27. 简答题

优先购买

时间限制:1.0 s

内存限制:512.0 MB

题目描述

小 A 有M元预算。商店有N个商品,每个商品有商品名S 、价格P和优先级V三种属性,其中V为正整数,且V越小代表商品的优先级越高。

小 A 的购物策略为:

总是优先买优先级最高的东西;

如果有多个最高优先级商品,购买价格最低的;

如果有多个优先级最高且价格最低的商品,购买商品名字典序最小的。

小 A 想知道能购买哪些商品。

输入格式

第一行两个正整数 M,N,代表预算和商品数。

之后N行,每行一个商品,依次为Si,Pi,Vi ,代表第 个商品的商品名、价格、优先级。数据保证不存在两个名字相同的商品。

输出格式

按照字典序从小到大的顺序,输出所有购买商品的商品名。

输入样例

20 4
apple 6 8
bus 15 1
cab 1 10
water 4 8

输出样例

bus
cab
water

数据范围

对于所有测试点,保证商品名仅由小写字母组成且不存在两个相同的商品名。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string&gt; #include &lt;map&gt; #include &lt;assert.h&gt; using namespace std; struct Item {     string name;     int price;     int priority; }; bool cmp(const Item &amp;a, const Item &amp;b) {     if (a.priority != b.priority)         return a.priority &lt; b.priority;     if (a.price != b.price)         return a.price &lt; b.price;     return a.name &lt; b.name; } string s[1005]; std::map&lt;string, int&gt; mp; int main() {     int M, N;     cin &gt;&gt; M &gt;&gt; N;     Item items[N];          for (int i = 0; i &lt; N; ++i) {         cin &gt;&gt; items[i].name &gt;&gt; items[i].price &gt;&gt; items[i].priority;         assert(mp.find(items[i].name) == mp.end());         mp[items[i].name] = items[i].priority;     }          sort(items, items + N, cmp);     int budget = M;     int count = 0;          for (int i = 0; i &lt; N; ++i) {         if (items[i].price &lt;= budget) {             budget -= items[i].price;             s[count++] = items[i].name;         }     }          sort(s, s + count);     for (int i = 0; i &lt; count; ++i) {         cout &lt;&lt; s[i] &lt;&lt; endl;     }          return 0; }</pre>
这道题暂未补解析。