c++ STL 之队列——queue 详解

必胜的小铭

已于 2024-05-19 16:27:01 修改

阅读量582

点赞数 16

分类专栏： c++ STL 文章标签： c++ 开发语言数据结构柔性数组容器

于 2024-05-18 16:12:00 首次发布

本文链接：https://blog.csdn.net/zhhg0123/article/details/139021966

版权

c++ STL 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

queue 是 stl 的一个关联容器,名叫“队列”，何为“队列”？其实就是一个数组，但有了数组何必还需栈，~~这是一个高深的问题。~~

一、简介

queue 顾名思义就是队列，和买菜时排的队一样，从队尾入队，从队首出队，先进先出（FIFO），STL 中的 queue 没有迭代器，不支持遍历，只能访问队首、队首元素。

queue 其实就是禁用了 deque（双向队列）的反向出入队，它的核心部分“c”就是 deque。

protected:
    container_type c;

二、用法

引用 queue 头文件：

#include <queue>

定义：

queue <int> MyQueue;

三、相关函数

1. push

入队：

MyQueue.push(0)

2. pop

出队：

MyQueue.pop();

3. front

访问队首元素：

MyQueue.front(); // 不是 top！！！

4. back

访问队尾元素：

MyQueue.back();

5. size

查询队列大小：

cout << MyQueue.size();

6. empty

检查队列是否为空，为空返回 true ，否则返回 true。

if (MyQueue.empty())
{
    cout << "empty!";
}

三、应用

queue 的主要应用在广度优先搜索（即层次遍历、泛洪算法），就好像一场洪水一样，从一个点逐渐扩散、在扩散。和深搜不同，深搜是派一个人走到头，退回来，再走，这样要把所有的路都走一遍，广度优先搜索则是每到一个岔路都要“分身”，适合求无权值的单源最短路。但怎么记录搜索顺序呢，数组？不行，太麻烦了，需要双指针。这是队列就派上用场了！

例题：

URL：[CCC 2024 J5] Harvest Waterloo - 洛谷

题目：P10294 [CCC 2024 J5] Harvest Waterloo

题目描述

有一款新出现的广受欢迎的收割模拟游戏叫做 Harvest Waterloo。游戏在一块矩形南瓜地上进行，南瓜地里有成捆的干草和不同大小的南瓜。游戏开始时，一个农民在其中一个南瓜的位置上。

农民通过在整片土地上向左、向右、向上或向下移动来收割南瓜。农民不能斜着移动，不能穿过干草，也不能离开田地。

你的工作是确定农民收获的南瓜的总价值。其中一个小南瓜值 11 美元，一个中等大小的南瓜值 55 美元，而一个大南瓜值 1010 美元。

输入格式

输入的第一行是一个整数 𝑅>0 表示南瓜地的行数。

第二行是一个整数 𝐶>0 表示南瓜地的列数。

接下来 𝑅 行描述了整个南瓜地。每行包含 𝐶 个字符并且每个字符要么表示一个南瓜，要么表示干草：S 表示小南瓜，M 表示中等大小的南瓜，L 表示一个大南瓜，* 表示干草。

下一行包含一个整数 𝐴 满足 0≤𝐴<𝑅 最后一行是一个整数 𝐵 满足 0≤𝐵<𝐶。表示农民一开始在第 𝐴 行第 𝐵 列的位置。南瓜地的左上角称为第 0 行第 0 列。

输出格式

输出一个整数 𝑉V 表示农民能够收割的南瓜的总价值。

输入输出样例

输入 #1 输出 #1

6                37
6
**LMLS
S*LMMS
S*SMSM
******
LLM*MS
SSL*SS
5
1

输入 # 输出 #2

6                 88
6
**LMLS
S*LMMS
S*SMSM
***SLL
LLM*MS
SSL*SS
2
4

#include<iostream>
#include<stack>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string>
#include<list>
#include<iomanip>
#include<map>
#include<queue>
#include<vector>
#include<limits>
#include<cstring>
#include<bitset>
#include<climits>
#include<stdlib.h>
#include<time.h>
#include<set>
using namespace std;

string s[100001];

int dx[5]={0, 0, 0, 1, -1};
int dy[5]={0, 1, -1, 0, 0}; // 方向

struct st{
	int x, y;
	st(int a, int b){
		x=a;
		y=b;
	}
}; // 坐标

int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);//关同步加快输入输出

	int r, c;
	cin >> r >> c;
	for(int i = 0; i < r; i ++)
    {
		cin >> s[i];
	} // 输入地图

	int bx, by;
	cin >> bx >> by;//输入起始位置

	queue <st> q; // 创建队列，记录顺序
	q.push(st(bx, by)); //把起始节点入队
	int ans = 0;
	switch(s[bx][by]){
		case 'S':
            ans += 1;
            break;
		case 'M':
            ans +=5 ;
            break;
		case 'L':
            ans+=10;
            break;
	}

	s[bx][by] = '*';
	while(!q.empty()){
		int x = q.front().x;
		int y = q.front().y;
		q.pop(); //出队
		for(int i = 1;i <= 4;i ++)
        {
			int tx = x + dx[i];
			int ty = y + dy[i]; // 表示(x,y)可以到达(tx,ty)

			if(tx >= 0 && tx < r && ty >= 0 && ty < c)
            {
				switch(s[tx][ty])
                {
                    case '*':
                        goto f; // 不能走
            	    case 'S':
                        ans += 1;
                        break;
            		case 'M':
                        ans +=5 ;
                        break;
               		case 'L':
                        ans+=10;
                        break;
	            }
				q.push(st(tx,ty)); //入队，等待访问
				s[tx][ty]='*'; // 不能再次到达(tx,ty)，作标记
				f:;
			}
		}
	}

	cout << ans;
	return 0;
}

请勿抄袭代码，可能会收到棕名或封号惩罚！！！

SPFA 算法是 BF 算法的队列优化版本，适用于有权值的单源最短路时间复杂度为 $O(kE)$ ，很快，其中 k 为常数，平均w为 2，E 为边数，但因为大多数数据卡 SPFA，且 CSP-J 考纲不涉及，故不加叙述。

必胜的小铭

关注

16
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
c++ STL 之队列——queue 详解

queue顾名思义就是队列，和买菜时排的队一样，从队尾入队，从队首出队，先进先出（FIFO），STL 中的 queue 没有迭代器，不支持遍历，只能访问队首、队首元素。queue 其实就是禁用了 deque（双向队列）的反向出入队，它的核心部分“c”就是 deque。
复制链接

扫一扫