乘车顺序(2026.10.25)
2026年最新华为OD机考题库(按考点分类): 2026年最新华为OD机考题库
题目描述
某中小学在暑假期间组织学生参观,带队老师让学生在排队上车前做游戏,通过游戏决定大家的乘车顺序。
学校共有 X 名学生,学号为 1 到 X。游戏开始时,学生按学号递增的顺序排成一列。每轮游戏中,老师给出两个学号 A 和 B,并根据这两名学生在当前队列中的位置调整队列:
- 若 A 在 B 之前,或者 A 与 B 是同一名学生,则将从 A 到 B 的连续一段学生(包括 A 和 B)按原顺序移动到队伍最前面,其余学生保持相对顺序。
- 若 A 在 B 之后,则将 B 之前的所有学生(不包括 B)按原顺序移动到队伍最末尾,其余学生保持相对顺序。
完成 Y 轮游戏后,输出最终的乘车顺序。
输入描述
三个参数:学生总数 X、游戏轮数 Y、二维数组 rounds,其中 rounds[i] = [A_i, B_i] 表示第 i 轮给出的两个学号。
数据范围
1≤Y≤X≤1200,1≤Ai,Bi≤X。Ai 和 Bi 可以相同。
输出描述
返回最终乘车顺序,即一个长度为 X 的学号数组。
样例
用例输入 1
5,3,[[3,5],[5,1],[3,4]]
用例输出 1
[3,4,5,1,2]
用例解释 1
- 初始队列为
[1,2,3,4,5]。 - 第 1 轮给出
[3,5],将[3,4,5]移到队首,得到[3,4,5,1,2]。 - 第 2 轮给出
[5,1],此时 5 在 1 之前,将[5,1]移到队首,得到[5,1,3,4,2]。 - 第 3 轮给出
[3,4],将[3,4]移到队首,最终得到[3,4,5,1,2]。
用例输入 2
5,2,[[4,2],[3,3]]
用例输出 2
[3,2,4,5,1]
用例解释 2
- 第 1 轮给出
[4,2],4 在 2 之后,将 2 之前的学生[1]移到队尾,队列变为[2,3,4,5,1]。 - 第 2 轮给出
[3,3],将学生 3 单独移到队首,最终得到[3,2,4,5,1]。
来源
本题来源于网络、非官方材料、仅供学习交流,侵删
🧠 解题思路
第一步:用一个数组表示队列
队列初始为 [1, 2, …, X]。每轮游戏只是把队列切成几段、换个顺序再拼起来,用数组的切片和拼接就能直接模拟。
第二步:每轮先找位置
学号在队列里的位置每轮都会变,所以每轮都要在当前队列里重新查找 A、B 的下标 pa、pb。从头扫一遍找即可。
第三步:分两种情况重排
情况 1:pa ≤ pb(A 在 B 前面,或 A、B 是同一人)。把 [pa, pb] 这一段原样搬到最前面:
新队列 = q[pa…pb] + q[0…pa-1] + q[pb+1…末尾]
情况 2:pa > pb(A 在 B 后面)。把 B 前面的所有人(不含 B)原样搬到最后面:
新队列 = q[pb…末尾] + q[0…pb-1]
两种情况里,各段内部的顺序都不变,正好满足“其余学生保持相对顺序”。
第四步:为什么直接模拟够快
每轮查找和拼接都是 O(X),共 Y 轮。按 X ≤ 1200、Y ≤ X 算,最坏约 1.44×10⁶ 次操作,很快,不需要链表之类的结构。
用样例 1 走一遍
X = 5,初始队列 [1, 2, 3, 4, 5]。
| 轮 | A, B | pa, pb | 情况 | 操作 | 新队列 |
|---|---|---|---|---|---|
| 1 | 3, 5 | 2, 4 | pa ≤ pb | [3, 4, 5] 搬到最前 | [3, 4, 5, 1, 2] |
| 2 | 5, 1 | 2, 3 | pa ≤ pb | [5, 1] 搬到最前 | [5, 1, 3, 4, 2] |
| 3 | 3, 4 | 2, 3 | pa ≤ pb | [3, 4] 搬到最前 | [3, 4, 5, 1, 2] |
输出 [3, 4, 5, 1, 2]。注意第 2 轮学号 5 比 1 大,但在当前队列里 5 排在 1 前面,所以走的是情况 1,比较的是位置不是学号。
样例 2 两种情况都有:第 1 轮 (4, 2),队列 [1, 2, 3, 4, 5] 中 pa = 3 > pb = 1,把 2 前面的 [1] 搬到最后,得 [2, 3, 4, 5, 1];第 2 轮 (3, 3) 是同一人,pa = pb = 1,把 [3] 搬到最前,得 [3, 2, 4, 5, 1]。
⚠️ 易错点
- A 与 B 相同时属于 A 在 B 之前的分支,应把该学生单独移到队首。
- A 在 B 之后时移动的是 B 之前的所有学生,不包括 B 本身。
- 每轮都要基于当前队列重新定位 A、B 的下标,不能使用初始学号顺序,也不能比较学号大小。
- 移动后其余学生的相对顺序必须保持不变。
⏱️ 复杂度
时间复杂度:O(Y·X),其中 X ≤ 1200、Y ≤ X,最坏约 1.44×10⁶ 次基本操作。
空间复杂度:O(X),用于存储当前队列和每轮拼接出的新队列。
💻 参考代码(Java)
import java.util.*;
class Solution {
public int[] boardingOrder(int X, int Y, int[][] rounds) {
// 初始队列:学号 1..X 递增
int[] q = new int[X];
for (int i = 0; i < X; i++) q[i] = i + 1;
for (int i = 0; i < Y; i++) {
int a = rounds[i][0], b = rounds[i][1];
// 定位 A、B 在当前队列中的下标
int pa = -1, pb = -1;
for (int j = 0; j < X; j++) {
if (q[j] == a) pa = j;
if (q[j] == b) pb = j;
}
int[] nq = new int[X];
int k = 0;
if (pa <= pb) {
// A 在 B 之前(或同一人):[A..B] 整段移到队首
for (int j = pa; j <= pb; j++) nq[k++] = q[j];
for (int j = 0; j < pa; j++) nq[k++] = q[j];
for (int j = pb + 1; j < X; j++) nq[k++] = q[j];
} else {
// A 在 B 之后:B 之前的全部学生移到队尾
for (int j = pb; j < X; j++) nq[k++] = q[j];
for (int j = 0; j < pb; j++) nq[k++] = q[j];
}
q = nq;
}
return q;
}
}
💻 参考代码(C++)
class Solution {
public:
vector<int> boardingOrder(int X, int Y, vector<vector<int>> rounds) {
// 初始队列:学号 1..X 递增
vector<int> q(X);
for (int i = 0; i < X; i++) q[i] = i + 1;
for (int i = 0; i < Y; i++) {
int a = rounds[i][0], b = rounds[i][1];
// 定位 A、B 在当前队列中的下标
int pa = -1, pb = -1;
for (int j = 0; j < X; j++) {
if (q[j] == a) pa = j;
if (q[j] == b) pb = j;
}
vector<int> nq;
nq.reserve(X);
if (pa <= pb) {
// A 在 B 之前(或同一人):[A..B] 整段移到队首
for (int j = pa; j <= pb; j++) nq.push_back(q[j]);
for (int j = 0; j < pa; j++) nq.push_back(q[j]);
for (int j = pb + 1; j < X; j++) nq.push_back(q[j]);
} else {
// A 在 B 之后:B 之前的全部学生移到队尾
for (int j = pb; j < X; j++) nq.push_back(q[j]);
for (int j = 0; j < pb; j++) nq.push_back(q[j]);
}
q = nq;
}
return q;
}
};
💻 参考代码(Python)
class Solution:
def boardingOrder(self, X, Y, rounds):
# 初始队列:学号 1..X 递增
q = list(range(1, X + 1))
for i in range(Y):
a = rounds[i][0]
b = rounds[i][1]
# 定位 A、B 在当前队列中的下标
pa = q.index(a)
pb = q.index(b)
if pa <= pb:
# A 在 B 之前(或同一人):[A..B] 整段移到队首
seg = q[pa:pb + 1]
rest = q[:pa] + q[pb + 1:]
q = seg + rest
else:
# A 在 B 之后:B 之前的全部学生移到队尾
head = q[:pb]
rest = q[pb:]
q = rest + head
return q
💻 参考代码(JavaScript)
class Solution {
boardingOrder(X, Y, rounds) {
// 初始队列:学号 1..X 递增
let q = [];
for (let i = 1; i <= X; i++) q.push(i);
for (let i = 0; i < Y; i++) {
const a = rounds[i][0], b = rounds[i][1];
// 定位 A、B 在当前队列中的下标
const pa = q.indexOf(a);
const pb = q.indexOf(b);
if (pa <= pb) {
// A 在 B 之前(或同一人):[A..B] 整段移到队首
const seg = q.slice(pa, pb + 1);
const rest = q.slice(0, pa).concat(q.slice(pb + 1));
q = seg.concat(rest);
} else {
// A 在 B 之后:B 之前的全部学生移到队尾
const head = q.slice(0, pb);
const rest = q.slice(pb);
q = rest.concat(head);
}
}
return q;
}
}
module.exports = Solution;
270



被折叠的 条评论
为什么被折叠?



