华为OD机试 2024E卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
某银行将客户分为了若干个优先级，1级最高，5级最低，当你需要在银行办理业务时，优先级高的人随时可以插队到优先级低的人的前面。
现在给出一个人员到来和银行办理业务的时间序列，请你每次银行办理业务时输出客户的编号。
如果同时有多位优先级相同且最高的客户，则按最先到来的顺序办理。
二、输入描述
输入第一行是一个正整数n，表示输入的序列中的事件数量。（1 ≤ n ≤ 500）
接下来有n行，每行第一个字符为a或p。
当字符为a时，后面会有两个正整数num和x，表示到来的客户编号为num，优先级为x；
当字符为p时，表示当前优先级最高的客户去办理业务。
三、输出描述
输出包含若干行，对于字符p，输出一行，仅包含一个正整数num，表示办理业务的客户编号。
四、测试用例
测试用例1：
1、输入
4
a 1 3
a 2 2
a 3 2
p
2、输出
2
3、说明
客户2和客户3都是优先级2，客户2先到达，因此输出2。
测试用例2：
1、输入
6
a 10 1
a 20 5
a 30 3
p
p
p
2、输出
10
30
20
3、说明
客户10优先级1
客户20优先级5
客户30优先级3
第一次’p’处理客户10（优先级最高）
第二次’p’处理客户30（优先级3高于优先级5）
第三次’p’处理客户20
五、解题思路
客户根据优先级（1级最高，5级最低）到达银行，并且高优先级的客户可以随时插队到低优先级客户的前面。当银行办理业务时，需要按照优先级从高到低的顺序处理客户，如果有多个客户具有相同的最高优先级，则按照他们到达的顺序先后处理。
- 事件处理：
- 到达事件（‘a’）：记录客户的编号和优先级，并将其加入相应优先级的队列中。
- 办理业务事件（‘p’）：从最高优先级开始，找到第一个非空的队列，取出最先到达的客户进行办理，并输出其编号。
- 数据结构选择：
- 使用多个队列（每个优先级对应一个队列）来管理不同优先级的客户。
- 采用数组来存储这些队列，方便根据优先级快速访问对应的队列。
- 算法流程：
- 初始化5个队列，分别对应优先级1到5。
- 遍历所有事件，根据事件类型进行相应处理。
- 对于’p’事件，依次检查优先级从1到5的队列，找到第一个非空的队列，处理其中最先到达的客户。
六、Python算法源码
# 导入所需的库
from collections import deque
import sys
def main():
# 读取输入的所有行
input_lines = sys.stdin.read().splitlines()
# 第一行是事件数量n
n = int(input_lines[0])
# 初始化5个队列，索引1到5分别对应优先级1到5
priority_queues = [deque() for _ in range(6)] # 索引0不使用
# 遍历每一个事件
for i in range(1, n + 1):
# 获取当前事件的内容，并按空格分割
parts = input_lines[i].strip().split()
if parts[0] == 'a':
# 到达事件，获取客户编号和优先级
num = int(parts[1])
priority = int(parts[2])
# 将客户编号加入对应优先级的队列
priority_queues[priority].append(num)
elif parts[0] == 'p':
# 办理业务事件，查找最高优先级的客户
processed = False
for p in range(1, 6):
if priority_queues[p]:
# 取出队首客户并输出
customer = priority_queues[p].popleft()
print(customer)
processed = True
break
if not processed:
# 如果没有客户需要处理，输出提示信息
print("No customers to process.")
if __name__ == "__main__":
main()
七、JavaScript算法源码
// 使用 Node.js 的 readline 模块读取输入
const readline = require('readline');
// 创建接口
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: false
});
let inputLines = [];
let n = 0;
let currentLine = 0;
// 定义5个队列，索引1到5对应优先级1到5
let priorityQueues = [[], [], [], [], [], []]; // 索引0不使用
rl.on('line', function(line){
inputLines.push(line);
}).on('close', function(){
// 读取事件数量
n = parseInt(inputLines[0]);
// 处理每一个事件
for(let i = 1; i <= n; i++){
let parts = inputLines[i].trim().split(' ');
if(parts[0] === 'a'){
// 到达事件，获取客户编号和优先级
let num = parseInt(parts[1]);
let priority = parseInt(parts[2]);
// 将客户加入对应优先级的队列
priorityQueues[priority].push(num);
}
else if(parts[0] === 'p'){
// 办理业务事件，查找最高优先级的客户
let processed = false;
for(let p = 1; p <=5; p++){
if(priorityQueues[p].length > 0){
// 取出队首客户并输出
let customer = priorityQueues[p].shift();
console.log(customer);
processed = true;
break;
}
}
if(!processed){
// 如果没有客户需要处理，输出提示信息
console.log("No customers to process.");
}
}
}
});
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 定义队列节点结构体
typedef struct Node {
int num; // 客户编号
struct Node* next; // 指向下一个节点
} Node;
// 定义队列结构体
typedef struct Queue {
Node* front; // 队首
Node* rear; // 队尾
} Queue;
// 初始化队列
void initQueue(Queue* q){
q->front = q->rear = NULL;
}
// 判断队列是否为空
int isEmpty(Queue* q){
return q->front == NULL;
}
// 入队操作
void enqueue(Queue* q, int num){
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->num = num;
newNode->next = NULL;
if(isEmpty(q)){
q->front = q->rear = newNode;
}
else{
q->rear->next = newNode;
q->rear = newNode;
}
}
// 出队操作，返回客户编号
int dequeue(Queue* q){
if(isEmpty(q)){
return -1; // 表示队列为空
}
Node* temp = q->front;
int num = temp->num;
q->front = q->front->next;
if(q->front == NULL){
q->rear = NULL;
}
free(temp);
return num;
}
int main(){
int n;
// 读取事件数量
scanf("%d", &n);
// 初始化5个队列，索引1到5对应优先级1到5
Queue priorityQueues[6]; // 索引0不使用
for(int i=1;i<=5;i++){
initQueue(&priorityQueues[i]);
}
// 读取剩余的换行符
getchar();
// 处理每一个事件
for(int i=0;i<n;i++){
char line[100];
fgets(line, sizeof(line), stdin);
// 去除末尾换行符
line[strcspn(line, "\n")] = 0;
if(line[0] == 'a'){
int num, priority;
// 解析客户编号和优先级
sscanf(line + 2, "%d %d", &num, &priority);
// 将客户加入对应优先级的队列
enqueue(&priorityQueues[priority], num);
}
else if(line[0] == 'p'){
// 办理业务事件，查找最高优先级的客户
int processed = 0;
for(int p=1;p<=5;p++){
if(!isEmpty(&priorityQueues[p])){
int customer = dequeue(&priorityQueues[p]);
printf("%d\n", customer);
processed = 1;
break;
}
}
if(!processed){
// 如果没有客户需要处理，输出提示信息
printf("No customers to process.\n");
}
}
}
// 释放内存（可选，此处略）
return 0;
}
九、C++算法源码
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <sstream>
using namespace std;
int main(){
int n;
// 读取事件数量
cin >> n;
cin.ignore(); // 忽略剩余的换行符
// 初始化5个队列，索引1到5对应优先级1到5
vector<queue<int>> priorityQueues(6, queue<int>()); // 索引0不使用
// 处理每一个事件
for(int i=0;i<n;i++){
string line;
getline(cin, line);
// 使用字符串流解析
stringstream ss(line);
string type;
ss >> type;
if(type == "a"){
int num, priority;
ss >> num >> priority;
// 将客户加入对应优先级的队列
priorityQueues[priority].push(num);
}
else if(type == "p"){
// 办理业务事件，查找最高优先级的客户
bool processed = false;
for(int p=1;p<=5;p++){
if(!priorityQueues[p].empty()){
int customer = priorityQueues[p].front();
priorityQueues[p].pop();
cout << customer << endl;
processed = true;
break;
}
}
if(!processed){
// 如果没有客户需要处理，输出提示信息
cout << "No customers to process." << endl;
}
}
}
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
