Day 11 · 结构体：把相关的数据打包

题意：给出 N 个同学的姓名和三科成绩，找出总分最高的那位， 输出他的姓名和原始三科成绩（注意：不是输出总分，是输出原始的三科分数）。 如果有多个人总分并列最高，输出输入靠前的那位。

思路

这题是结构体的「Hello World」，用打擂台的思路就够了，不需要真的排序：

1. 把 N 个同学读进结构体数组，顺手算出每个人的 total。
2. 假设第 0 个同学最厉害（best = 0）。
3. 从第 1 个开始逐个挑战擂主：只要我的总分严格大于擂主，我就当新擂主。
4. 输出擂主的姓名和三科成绩。

「并列时输出靠前的」怎么实现？关键在第 3 步的「严格大于」—— 用 > 而不是 >=。总分相等时擂台不换人，自然就保留了靠前的那位。

3
senpai 114 51 4
lxl 114 10 23
fafa 51 42 60

senpai 114 51 4

三个人总分：senpai = 114+51+4 = 169，lxl = 114+10+23 = 147，fafa = 51+42+60 = 153。最高的是 senpai。

完整代码

#include <iostream>
#include <string>
using namespace std;

// 结构体：把「一个同学的全部信息」打包成一个整体
struct Student {
    string name;                    // 姓名
    int chinese, math, english;     // 三科成绩
    int total;                      // 派生字段：总分（读入之后算出来）
} a[1005];                          // 结构体数组：一次声明 1005 个同学

int main(){
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        // 结构体数组的输入：a[i] 是一个整体，用 a[i].字段 逐个点名
        cin >> a[i].name >> a[i].chinese >> a[i].math >> a[i].english;
        a[i].total = a[i].chinese + a[i].math + a[i].english;
    }

    int best = 0;                   // best 记住「目前最厉害的同学」的下标
    for(int i = 1; i < n; i++){
        if(a[i].total > a[best].total){   // ★ 用 > 不用 >=：并列时保留靠前的
            best = i;
        }
    }

    cout << a[best].name << " " << a[best].chinese << " "
         << a[best].math << " " << a[best].english << endl;
    return 0;
}

易错点

• 输出的是三科原始成绩，不是总分！题目说「输出最厉害的学生各项信息（姓名、各科成绩）」， 很多人顺手把 total 输出了，直接 0 分。
• 比较用了 >=：并列时后面的会顶掉前面的，违反了「输出靠前的那位」。
• 结构体定义末尾的 }; 分号忘了写。
• 姓名是 string，要用 #include <string>（虽然很多编译器不写也能过， 但规范起见写上）。

题意：n 个学生，每人有语文、数学、英语三科成绩。按下面的规则排出一个唯一确定的名次，然后输出前 5 名的学号和总分。

排序规则：① 总分从高到低；② 总分相同时语文从高到低；③ 总分和语文都相同时学号小的在前。

思路

这是结构体 + 多关键字排序的标准题。

1. 读入时把学号也存进结构体（a[i].id = i;）——排序会把顺序打乱，学号必须跟着人走。
2. 顺手算总分。
3. 写三行 cmp，把三个优先级依次排好。
4. sort 之后，前 5 个就是获奖的同学，输出 id 和 total。

6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98

6 265
4 264
3 258
2 244
1 237

手算验证：1 号 237、2 号 244、3 号 258、4 号 264、5 号 220、6 号 265。按总分降序正好是 6、4、3、2、1。

完整代码

#include <iostream>
#include <algorithm>
using namespace std;

struct Student {
    int id;                         // 学号
    int chinese, math, english;     // 三科成绩
    int total;                      // 总分
} a[305];

// 比较函数：返回 true 表示 x 应该排在 y 前面
bool cmp(const Student &x, const Student &y){
    if(x.total != y.total) return x.total > y.total;         // ① 总分高的在前
    if(x.chinese != y.chinese) return x.chinese > y.chinese;  // ② 语文高的在前
    return x.id < y.id;                                      // ③ 学号小的在前
}

int main(){
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++){
        a[i].id = i;                                    // ★ 学号 = 输入行号，必须存下来
        cin >> a[i].chinese >> a[i].math >> a[i].english;
        a[i].total = a[i].chinese + a[i].math + a[i].english;
    }

    // 注意：数据存在 a[1] ~ a[n]，所以是 sort(a+1, a+n+1, cmp)
    sort(a + 1, a + n + 1, cmp);

    for(int i = 1; i <= 5; i++){
        cout << a[i].id << " " << a[i].total << endl;
    }
    return 0;
}

易错点

• 三个关键字的顺序写反。优先级是总分 → 语文 → 学号，一层一层往下筛。
• 把 if(x.total != y.total) 写成 if(x.total > y.total)， 会让总分相等的人错误地按学号重排。
• 忘记存学号，排序后完全不知道输出谁。
• sort 右端点漏了 +1，最后一个学生没排序。
• 输出只有 5 行，别写成 n 行。

题意：给出 n 个人的姓名、出生年、月、日，按年龄从大到小输出姓名。 如果两个人年龄相同（年月日完全一样），输入靠后的同学先输出。

思路

先想清楚一件事：「年龄大」等价于「出生日期早」。所以「年龄从大到小」就是「出生日期从小到大」。

日期怎么比大小？就是看日历的习惯：先比年，年相同再比月，月相同再比日。 这正好又是三段式 cmp：

先比 y（早的在前）→ 再比 m（早的在前）→ 再比 d（早的在前）

3
Yangchu 1992 4 23
Qiujingya 1993 10 13
Luowen 1991 8 1

Luowen
Yangchu
Qiujingya

Luowen 1991 年最早 → 年龄最大 → 排第一；Qiujingya 1993 年最晚 → 最小 → 排最后。

完整代码

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

struct Person {
    string name;        // 姓名
    int y, m, d;        // 出生年、月、日
    int id;             // 输入顺序（第几个读进来的）
} a[105];

// 比较函数：返回 true 表示 x 应该排在 y 前面（年龄大的在前）
bool cmp(const Person &x, const Person &y){
    if(x.y != y.y) return x.y < y.y;    // 出生年份小 → 年龄大 → 排前面
    if(x.m != y.m) return x.m < y.m;    // 同年再比月
    if(x.d != y.d) return x.d < y.d;    // 同月再比日
    return x.id > y.id;                 // ★ 生日完全相同：输入靠后的先输出
}

int main(){
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++){
        a[i].id = i;
        cin >> a[i].name >> a[i].y >> a[i].m >> a[i].d;
    }

    sort(a + 1, a + n + 1, cmp);

    for(int i = 1; i <= n; i++){
        cout << a[i].name << endl;
    }
    return 0;
}

易错点

• 把日期当成一个整数比（比如 y*10000+m*100+d）——这题碰巧也能过， 但更清楚的写法就是三段 if，可读性高得多。
• 年月日的比较方向搞反。题目要「年龄大在前」=「出生早在前」= x.y < y.y， 不是 >。写下 cmp 之前先在纸上念一遍题目要求。
• 并列时用 x.id < y.id：那会变成「输入靠前的先输出」，跟题目要求正好相反。
• 姓名是 string 不是 char，输出时直接 cout << a[i].name。

题意：有 N 个标了三维坐标 (x, y, z) 的点，所有点的高度 z 互不相同。 要从最低的点爬到最高的点，经过每一个点，而且每走一步高度都必须上升。 一步的距离是两点的三维欧几里得距离，求总距离（保留三位小数）。

思路

这题的巧妙之处在「把三维问题变成一维排序问题」。

题目的约束是「每一步高度 z 都必须上升」，而且「经过每一个点」。 那么攀爬路径其实已经被唯一确定了——就是把所有点按 z 从小到大排一排，依次走过去。

排完序，从 p[0] 顺着算到 p[n-1]，把相邻两点的三维距离加起来就行。

三维距离公式

平面上两点距离你会了：√((x₂-x₁)² + (y₂-y₁)²)。三维就是再多加一项 z：

√( (x₂-x₁)² + (y₂-y₁)² + (z₂-z₁)² )

平方差了再开根，用 sqrt()（需要 #include <cmath>）。

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

6.928

按 z 排序后是 (1,1,1) (2,2,2) (3,3,3) (4,4,4) (5,5,5)， 每相邻两点的距离都是 √(1+1+1) = √3 ≈ 1.7320508，四段共 ≈ 6.9282 → 保留三位小数 6.928。

完整代码

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;

struct Point {
    int x, y, z;        // 三维坐标
} p[50005];

// 按高度 z 从小到大排，就得到了攀爬的先后顺序
bool cmp(const Point &a, const Point &b){
    return a.z < b.z;
}

int main(){
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        scanf("%d %d %d", &p[i].x, &p[i].y, &p[i].z);
    }

    sort(p, p + n, cmp);            // 排序之后，p[0] 最低，p[n-1] 最高

    double ans = 0.0;
    for(int i = 1; i < n; i++){
        // 三维欧几里得距离：先算差值再平方，最后开根号
        double dx = p[i].x - p[i-1].x;
        double dy = p[i].y - p[i-1].y;
        double dz = p[i].z - p[i-1].z;
        ans += sqrt(dx * dx + dy * dy + dz * dz);
    }

    printf("%.3f\n", ans);          // 保留三位小数
    return 0;
}

易错点

• 用 int 算平方和：(p[i].x-p[i-1].x) 的平方可能超出 int 范围。 先赋给 double 变量再平方，或者写 (double) 强转。
• 忘了 #include <cmath>：sqrt 找不到。
• 输出格式：题目要求保留 3 位小数，cout << ans 会打出 6.9282 这种一堆位数，直接 WA。
• 数组开小了：N ≤ 50000，开 p[50005]，别开成 1005。
• 不要试图去找「最短路径」——路径是被题目条件唯一确定的，只需要排序 + 累加。