本多敏行1. ACM竞赛中的队列基础概念
队列（Queue）是ACM竞赛中最基础也是最重要的数据结构之一。它是一种先进先出（FIFO）的线性表，只允许在表的前端（front）进行删除操作，在表的后端（rear）进行插入操作。在ACM竞赛中，队列的应用场景非常广泛，从简单的模拟问题到复杂的图论算法都离不开它。
1.1 队列的基本特性
队列的核心特性可以用"先来先服务"的原则来理解。想象你在食堂排队打饭，先来的人先打到饭，后来的人只能排在队尾。这种特性使得队列特别适合处理需要按顺序处理元素的场景。
队列的基本操作包括：
- enqueue（入队）：在队尾添加元素
- dequeue（出队）：移除队首元素
- front/peek（查看队首）：获取但不移除队首元素
- isEmpty（判空）：检查队列是否为空
- size（大小）：获取队列中元素数量
1.2 队列在ACM中的典型应用
在ACM竞赛中，队列最常见的应用场景包括：
- 广度优先搜索（BFS）：这是队列最经典的应用，用于图的层次遍历
- 滑动窗口问题：维护一个固定大小的窗口在数据上滑动
- 任务调度：模拟操作系统中的进程调度
- 缓冲区管理：处理数据流中的缓冲
- 模拟问题：如银行排队系统模拟
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 队列的实现方式与性能分析
2.1 基于数组的实现（循环队列）
循环队列是解决普通数组实现队列时"假溢出"问题的有效方案。它的核心思想是将队列视为一个环状结构，通过两个指针（front和rear）来追踪队列的首尾位置。
cpp复制#define MAX_SIZE 100
class CircularQueue {
private:
int data[MAX_SIZE];
int front, rear;
public:
CircularQueue() : front(0), rear(0) {}
bool enqueue(int x) {
if ((rear + 1) % MAX_SIZE == front) // 队列满
return false;
data[rear] = x;
rear = (rear + 1) % MAX_SIZE;
return true;
}
bool dequeue(int &x) {
if (front == rear) // 队列空
return false;
x = data[front];
front = (front + 1) % MAX_SIZE;
return true;
}
};
注意：循环队列中会故意浪费一个空间来区分队列满和队列空的状态。这是实现中的关键细节。
2.2 基于链表的实现
链表实现的队列更加灵活，不受固定大小的限制，适合元素数量变化大的场景。
cpp复制struct Node {
int data;
Node* next;
Node(int x) : data(x), next(nullptr) {}
};
class LinkedQueue {
private:
Node* front;
Node* rear;
public:
LinkedQueue() : front(nullptr), rear(nullptr) {}
void enqueue(int x) {
Node* newNode = new Node(x);
if (rear == nullptr) {
front = rear = newNode;
} else {
rear->next = newNode;
rear = newNode;
}
}
bool dequeue(int &x) {
if (front == nullptr)
return false;
x = front->data;
Node* temp = front;
front = front->next;
if (front == nullptr)
rear = nullptr;
delete temp;
return true;
}
};
2.3 STL中的队列实现
在ACM竞赛中，C++选手通常会直接使用STL中的queue容器，它默认基于deque实现：
cpp复制#include <queue>
std::queue<int> q;
// 基本操作
q.push(1); // 入队
q.pop(); // 出队
int x = q.front(); // 获取队首元素
bool isEmpty = q.empty(); // 判断是否为空
size_t size = q.size(); // 获取队列大小
提示：在ACM竞赛中，除非题目有特殊要求，否则建议直接使用STL queue，可以节省编码时间并减少出错概率。
3. 队列在BFS算法中的应用
广度优先搜索（BFS）是队列最经典的应用场景，也是ACM竞赛中必须掌握的核心算法之一。
3.1 标准BFS模板
cpp复制void BFS(Node* start) {
if (start == nullptr) return;
queue<Node*> q;
unordered_set<Node*> visited;
q.push(start);
visited.insert(start);
while (!q.empty()) {
Node* current = q.front();
q.pop();
// 处理当前节点
process(current);
// 遍历邻居节点
for (Node* neighbor : current->neighbors) {
if (visited.find(neighbor) == visited.end()) {
q.push(neighbor);
visited.insert(neighbor);
}
}
}
}
3.2 BFS中的常见变体
- 多源BFS：当有多个起点时，可以先将所有起点入队
- 双向BFS：从起点和终点同时开始搜索，适用于已知目标状态的情况
- 分层BFS：记录每个节点的层次信息
- 优先队列BFS：实际上就是Dijkstra算法
3.3 BFS应用实例：迷宫最短路径
cpp复制struct Point {
int x, y;
Point(int x, int y) : x(x), y(y) {}
};
int shortestPath(vector<vector<int>>& grid, Point start, Point end) {
if (grid.empty() || grid[0].empty()) return -1;
int m = grid.size(), n = grid[0].size();
vector<vector<int>> dirs = {{-1,0}, {1,0}, {0,-1}, {0,1}};
queue<Point> q;
vector<vector<bool>> visited(m, vector<bool>(n, false));
q.push(start);
visited[start.x][start.y] = true;
int steps = 0;
while (!q.empty()) {
int size = q.size();
for (int i = 0; i < size; ++i) {
Point curr = q.front();
q.pop();
if (curr.x == end.x && curr.y == end.y)
return steps;
for (auto& dir : dirs) {
int nx = curr.x + dir[0], ny = curr.y + dir[1];
if (nx >= 0 && nx < m && ny >= 0 && ny < n &&
!visited[nx][ny] && grid[nx][ny] == 0) {
visited[nx][ny] = true;
q.push(Point(nx, ny));
}
}
}
steps++;
}
return -1;
}
注意：在BFS中记录步数时，常见的做法是在每层循环前获取当前队列大小，然后处理完这一批节点后步数加1。这是BFS算法中的关键技巧。
4. 高级队列结构与ACM竞赛应用
4.1 单调队列及其应用
单调队列是一种特殊的队列，它保持队列中的元素单调递增或单调递减。这种数据结构在解决滑动窗口最值问题时非常高效。
4.1.1 单调队列实现滑动窗口最大值
cpp复制vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> res;
deque<int> dq; // 存储的是下标
for (int i = 0; i < nums.size(); ++i) {
// 移除超出窗口范围的元素
while (!dq.empty() && dq.front() <= i - k)
dq.pop_front();
// 维护单调递减队列
while (!dq.empty() && nums[dq.back()] < nums[i])
dq.pop_back();
dq.push_back(i);
// 窗口形成后开始记录结果
if (i >= k - 1)
res.push_back(nums[dq.front()]);
}
return res;
}
4.1.2 单调队列的应用场景
- 滑动窗口最大值/最小值
- 限制最大容量的队列优化问题
- 某些动态规划问题的优化
4.2 优先队列（堆）与Dijkstra算法
虽然严格来说优先队列不是传统意义上的队列，但在ACM竞赛中它经常与队列一起讨论。C++中的priority_queue默认是大顶堆。
cpp复制#include <queue>
#include <vector>
// Dijkstra算法示例
void dijkstra(vector<vector<pair<int, int>>>& graph, int start) {
int n = graph.size();
vector<int> dist(n, INT_MAX);
dist[start] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, start});
while (!pq.empty()) {
auto [d, u] = pq.top();
pq.pop();
if (d > dist[u]) continue;
for (auto& [v, w] : graph[u]) {
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({dist[v], v});
}
}
}
}
4.3 双端队列（deque）与更灵活的队列操作
双端队列支持在两端进行插入和删除操作，结合了队列和栈的特性。
cpp复制#include <deque>
std::deque<int> dq;
// 前端操作
dq.push_front(1);
dq.pop_front();
// 后端操作
dq.push_back(2);
dq.pop_back();
在ACM竞赛中，deque常用于：
- 实现单调队列
- 某些特殊的BFS变体
- 滑动窗口问题
- 需要频繁在两端操作的场景
5. 队列相关竞赛题目解析与训练建议
5.1 经典队列题目分类
-
基础队列应用：
- 模拟排队系统
- 打印机任务调度
- 消息传递模拟
-
BFS相关题目：
- 迷宫最短路径
- 岛屿数量问题
- 单词接龙
- 腐烂的橘子
-
单调队列题目：
- 滑动窗口最大值
- 最大子数组和限制
- 某些动态规划优化
-
优先队列题目：
- 合并K个有序链表
- 查找中位数
- 任务调度器
5.2 队列训练建议
- 从基础开始：先熟练掌握STL queue的基本操作，然后尝试自己实现队列
- 理解BFS的本质：多做图的遍历问题，理解队列在BFS中的作用
- 掌握单调队列：这是面试和竞赛中的高频考点
- 注意边界条件：队列为空时的操作、循环队列的判满条件等
- 性能分析：理解不同实现方式的时间复杂度差异
5.3 队列题目实战解析：腐烂的橘子
cpp复制int orangesRotting(vector<vector<int>>& grid) {
int m = grid.size(), n = grid[0].size();
queue<pair<int, int>> q;
int fresh = 0, minutes = 0;
// 初始化：统计新鲜橘子数量，腐烂橘子入队
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == 1) fresh++;
else if (grid[i][j] == 2) q.push({i, j});
}
}
// 四个方向
vector<vector<int>> dirs = {{-1,0}, {1,0}, {0,-1}, {0,1}};
while (!q.empty() && fresh > 0) {
int size = q.size();
for (int i = 0; i < size; ++i) {
auto [x, y] = q.front();
q.pop();
for (auto& dir : dirs) {
int nx = x + dir[0], ny = y + dir[1];
if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == 1) {
grid[nx][ny] = 2;
fresh--;
q.push({nx, ny});
}
}
}
if (!q.empty()) minutes++;
}
return fresh == 0 ? minutes : -1;
}
这道题是多源BFS的典型应用，关键在于：
- 初始时将所有腐烂橘子入队
- 使用分层BFS记录时间
- 维护新鲜橘子的计数
5.4 队列在系统设计中的应用延伸
虽然ACM竞赛主要关注算法实现，但了解队列在实际系统中的应用也有助于加深理解：
- 消息队列（如RabbitMQ）在分布式系统中的应用
- 线程池中的任务队列
- 网络数据包缓冲队列
- 操作系统中的进程调度队列
在系统设计中，队列大小设置（如Java线程池的queueCapacity）需要考虑：
- 系统最大并发量
- 内存限制
- 任务处理速度
- 系统容错能力