【总结】队列与栈

最新推荐文章于 2023-10-09 22:12:05 发布
最新推荐文章于 2023-10-09 22:12:05 发布
阅读量248 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqbzlydd/article/details/104349232
版权

栈

进出在同一侧，且满足后进先出，先进后出

车厢调度(train)
有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n≤1000），分别按照顺序编号为1，2，3，…，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁轨，它就不能再回到车站C。
在这里插入图片描述

负责车厢调度的工作人员需要知道能否使它以a1,a2,…,an的顺序从B方向驶出，请来判断能否得到指定的车厢顺序。

解析：
观察发现，整个调度过程其实是在模拟入栈出栈的过程，而这个过程中，我们可以分成三种状态：栈前、栈中、栈后。我们可以发现，当某个数字出栈了，说明比它小的数字要么已经出栈了，要么还在栈里，不能是入栈前状态，并且在栈中的顺序是从大到小的(从栈顶往栈底看)，比如出5，那么1，2，3，4要么已经在5之前出了，要么还在栈中（假如1，3，4在栈中，从栈顶往栈底看依次为4，3，1），不能是入栈前的状态。如果某个数字要出栈，那么当前在栈中的数字都必须小于它，否则就与栈的性质矛盾，不合法，于是我们可以这样解决：

从第一个数字开始扫描，a[i]表示当前出栈的数字，如果有比a[i]大的数字还在栈中，那么就产生矛盾，输出“NO”；否则，标记当前数字a[i]为栈后状态，那么[1, a[i]-1]这些数字如果还没出栈，标记为栈中状态。具体我们可以用0表示为确定状态，1表示栈中状态，2表示栈后状态。

#include<cstdio>
#include<stack>
using namespace std;
stack<int> liu;
int n,a[1005],b[1005];
int main() {
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=n;j++) {
			if(b[i]==j) a[j]=2;
			if(a[j]==2) continue;
			else if(b[i]>j) {
				if(a[j]==0) a[j]=1;
			}
			else if(b[i]<j) {
				if(a[j]>0) {
					printf("NO");
					return 0;
				}
			}
		}
	}
	printf("YES");
}

字符串匹配问题(strs)
字符串中只含有括号 (),[],<>,{},判断输入的字符串中括号是否匹配。如果括号有互相包含的形式，从内到外必须是<>,(),[],{}，例如。输入: [()] 输出:YES，而输入([])，([)]都应该输出NO。

解析：简历四个栈，记录四种符号

  • 由于有优先级，所以当一个右括号匹配时，比他优先级低的括号必须已经匹配完成才行，左括号入栈即可，最后判断是否匹配完
#include<cstdio>
#include<stack>
#include<cstring>
using namespace std;
stack<int> a,b,c,d;
char s[300];
int n,len,flag;
int main() {
	scanf("%d",&n);
	for(int i=1;i<=n;i++) {
		flag=1;
		scanf("%s",s);
		len=strlen(s);
		for(int i=0;i<len;i++) {
			if(s[i]=='{') {
				a.push(1);
			}
			if(s[i]=='}') {
				if(a.empty()==1) {
					flag=0;
					break;
				}
				a.pop();
				if(b.empty()==0||c.empty()==0||d.empty()==0) {
					flag=0;
					break;
				}
			}
			if(s[i]=='[') {
				b.push(1);
			}
			if(s[i]==']') {
				if(b.empty()==1) {
					flag=0;
					break;
				}
				b.pop();
				if(c.empty()==0||d.empty()==0) {
					flag=0;
					break;
				}
			}
			if(s[i]=='(') {
				c.push(1);
			}
			if(s[i]==')') {
				if(c.empty()==1) {
					flag=0;
					break;
				}
				c.pop();
				if(d.empty()==0) {
					flag=0;
					break;
				}
			}
			if(s[i]=='<') {
				d.push(1);
			}
			if(s[i]=='>') {
				if(d.empty()==1) {
					flag=0;
					break;
				}
				d.pop();
			}
		}
		//判断是否匹配完
		if(a.empty()==0||b.empty()==0||c.empty()==0||d.empty()==0) {
			flag=0;
		}
		if(flag) printf("YES\n");
		else {//多组数据，要清空
			printf("NO\n");
			while(a.empty()==0) a.pop();
			while(b.empty()==0) b.pop();
			while(c.empty()==0) c.pop();
			while(d.empty()==0) d.pop();
		}
	}
}

中缀表达式值(expr)
前缀和后缀表达式都很容易求值，我们将中缀表达式转换成后缀表达式，且后缀表达式不需要括号。复杂度O(n)

  1. 建立一个符号栈，一个数字栈
  2. 如果遇到一个数，加入数字栈
  3. 如果遇到左括号，把左括号入符号栈
  4. 如果遇到右括号，不断取出符号栈顶并在数字栈中运算，直到栈顶为左括号，把左括号出栈
  5. 如果遇到运算符，**只要栈顶符号的优先级不低于新符号，就不断取出栈顶并运算，最后把新括号入栈。**优先级乘除乘方>加减>左括号
  6. 最终数字栈剩下的数字就是结果。
    分析：第五点保证了先进先出（优先级相同时）以及符号相互的优先级，第四点其实就是处理括号内的运算，在符号栈中越先出去的，在后缀运算中优先级更高
#include<cstdio>
#include<cmath>
#include<stack>
#include<cstring>
using namespace std;
//stack<char> f;
const int MAXN=1e6+5;
char a[MAXN],f[MAXN];
long long n,m,t,b[MAXN];
int main() {
	scanf("%s",a);
	n=strlen(a);
	for(int i=0;i<n;i++) {
		if(a[i]>='0'&&a[i]<='9') {
			int w=0;
			while(a[i]>='0'&&a[i]<='9') w=w*10+(a[i]-'0'),i++;
			b[++m]=w;
		} 
		if(a[i]=='(') f[++t]='(';
		else if(a[i]==')') {
			while(f[t]!='(') {
				char x=f[t];
				t--;
				if(x=='+') b[m-1]=b[m-1]+b[m],m--;
				if(x=='-') b[m-1]=b[m-1]-b[m],m--;
				if(x=='*') b[m-1]=b[m-1]*b[m],m--;
				if(x=='/') b[m-1]=b[m-1]/b[m],m--;
				if(x=='^') b[m-1]=pow(b[m-1],b[m]),m--;
			}
			t--;
		}
		else if(a[i]=='*'||a[i]=='/'||a[i]=='^') {
			while(f[t]=='*'||f[t]=='/'||f[t]=='^') {
				char x=f[t];
				t--;
				if(x=='*') b[m-1]=b[m-1]*b[m],m--;
				if(x=='/') b[m-1]=b[m-1]/b[m],m--;
				if(x=='^') b[m-1]=pow(b[m-1],b[m]),m--;
			}
			f[++t]=a[i];
		}
		else if(a[i]=='+'||a[i]=='-') {
			while(f[t]=='+'||f[t]=='-'||f[t]=='*'||f[t]=='/'||f[t]=='^') {
				char x=f[t];
				t--;
				if(x=='*') b[m-1]=b[m-1]*b[m],m--;
				if(x=='/') b[m-1]=b[m-1]/b[m],m--;
				if(x=='^') b[m-1]=pow(b[m-1],b[m]),m--;
				if(x=='+') b[m-1]=b[m-1]+b[m],m--;
				if(x=='-') b[m-1]=b[m-1]-b[m],m--;
			}
			f[++t]=a[i];
		}
		/*for(int i=1;i<=m;i++) printf("%d ",b[i]);
		printf("\n");*/
	}
	for(int i=t;i>=1;i--) {
		char x=f[i];
		if(x=='+') b[m-1]=b[m-1]+b[m],m--;
		if(x=='-') b[m-1]=b[m-1]-b[m],m--;
		if(x=='*') b[m-1]=b[m-1]*b[m],m--;
		if(x=='/') b[m-1]=b[m-1]/b[m],m--;
		if(x=='^') b[m-1]=pow(b[m-1],b[m]),m--;
	}
	printf("%lld",b[1]);
}

括号画家
写累了，直接看代码吧：
错误代码

#include<cstdio>
#include<cmath>
#include<stack>
#include<cstring>
#include<algorithm>
using namespace std;
stack<int> f;
const int MAXN=100005;
char s[MAXN];
int n,ans,t;
int main() {
	scanf("%s",s);
	n=strlen(s);
	for(int i=0;i<n;i++) {
		t++;
		if(s[i]=='('||s[i]=='['||s[i]=='{') f.push(s[i]);
		else if(f.empty()==1||(s[i]==')'&&f.top()!='(')||(s[i]==']'&&f.top()!='[')||(s[i]=='}'&&f.top()!='{')) {
			t=0;
			while(f.empty()==0) f.pop();
		}
		else f.pop();
		int m=f.size();
		ans=max(ans,t-m);
	}
	printf("%d",ans);
}

LJS的数据：
( ( ( { } [ ] ( ( ( )
正确输出：4
我的输出：6

为什么会这样呢？会发现我并没有考虑多出来的没有匹配的括号，计算时去掉了f.size()即栈的长度，如果在最左边，这种算法是成立的；而如果未匹配到的在中间，就是不满足题意，而我相当于把两个满足要求的子序列合并在一起了。只需判断当前子序列末尾与栈的是否完全相同即可

正解：

#include<cstdio>
#include<cmath>
#include<stack>
#include<cstring>
#include<algorithm>
using namespace std;
stack<int> f;
const int MAXN=100005;
char s[MAXN];
int n,ans,t;
int main() {
	scanf("%s",s);
	n=strlen(s);
	for(int i=0;i<n;i++) {
		t++;
		if(s[i]=='('||s[i]=='['||s[i]=='{') f.push(s[i]);
		else if(f.empty()==1||(s[i]==')'&&f.top()!='(')||(s[i]==']'&&f.top()!='[')||(s[i]=='}'&&f.top()!='{')) {
		//说明以后的子序列不能延续这以前的部分了，直接删除
			t=0;
			while(f.empty()==0) f.pop();
		}
		else f.pop();
		int m=f.size();
		bool flag=1;
		if(m!=0) {
			int b[MAXN]={},len=0;
			while(f.empty()==0) {
				b[++len]=f.top();
				f.pop();
			}
			for(int j=i-t+1;j<=i-t+m;j++) {
				if(s[j]!=b[m-(j-(i-t+1))]) flag=0;
			} 
			for(int i=len;i>=1;i--) f.push(b[i]);
			if(flag) ans=max(ans,t-m);
		}
		if(flag) ans=max(ans,t-m);
	}
	printf("%d",ans);
}

队列

进出在异侧，且满足先进先出，后进后出

占卜DIY

#include <cstdio>
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
//队列
//上次没有在操作完后统计，必须操作完后再统计
const int MAXN = 105;
queue<int> a[MAXN];
int x, ans, b[MAXN];
char c[MAXN];
//这道题从一边进入，另一边取出，且进入和取出的方向是固定的，所以用队列
//因为栈是从同一边进入和取出
int main() {
    for (int i = 1; i <= 12; i++) {
        for (int j = 1; j <= 4; j++) {
            cin >> c[j];
            if (c[j] == '0')
                c[j] = 10;
            else if (c[j] > '0' && c[j] <= '9')
                c[j] -= '0';
            else if (c[j] == 'A')
                c[j] = 1;
            else if (c[j] == 'J')
                c[j] = 11;
            else if (c[j] == 'Q')
                c[j] = 12;
            else if (c[j] == 'K')
                c[j] = 13;
        }
        for (int j = 4; j >= 1; j--) a[i].push(c[j]);
        //注意队列的方向
    }
    for (int j = 1; j <= 4; j++) {
        cin >> c[j];
        if (c[j] == '0')
            c[j] = 10;
        else if (c[j] > '0' && c[j] <= '9')
            c[j] -= '0';
        else if (c[j] == 'A')
            c[j] = 1;
        else if (c[j] == 'J')
            c[j] = 11;
        else if (c[j] == 'Q')
            c[j] = 12;
        else if (c[j] == 'K')
            c[j] = 13;
        a[13].push(c[j]);
        //注意队列的方向
    }
    for (int i = 1; i <= 4; i++) {
        x = a[13].front(), a[13].pop();
        while (1) {
            if (x >= 100)
                x -= 100;
            if (x == 13) {
                break;
            }
            int t = x;
            a[t].push(x + 100);
            x = a[t].front();
            a[t].pop();
        }
    }
    for (int i = 1; i <= 12; i++) {
        while (a[i].empty() == 0) {
            int t = a[i].front();
            a[i].pop();
            if (t > 100)
                b[t - 100]++;
        }
    }
    for (int i = 1; i <= 12; i++) {
        if (b[i] == 4)
            ans++;
    }
    printf("%d", ans);
}
仰望星空的蚂蚁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
车厢调度：最基础的栈
hezhixingde的博客
08-24 2221
车厢调度： 题目描述 有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n<=1000），分别按照顺序编号为1，2，3，…，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁轨，它就不能再回到车站C。 负责车厢调度的工作人员需要知道能否使它以a1,a2,…,an的顺序从B方向驶出，请来判断
自定义的栈与队列
01-04
本文将深入探讨自定义的栈与队列的实现，以及如何利用这两个数据结构的特性来解决问题。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构。它遵循“先进后出”的原则，类似于现实生活中的堆...
车厢调度
clover_hxy的博客
12-04 5859
车厢调度(train.cpp) 【问题描述】       有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n       负责车厢调度的工作人员需要知道能否使它以a1,a2,…,an的顺序从B方向驶出，请来判断能否得到指定的车厢顺序。 【输入】train.in       输入文件的第一行为一个整数
1489车厢调度(train)（栈）
北邮22级信通一枚
02-11 465
解析：观察发现，整个调度过程其实是在模拟入栈出栈的过程，而这个过程中，我们可以分成三种状态：栈前、栈中、栈后。我们可以发现，当某个数字出栈了，说明比它小的数字要么已经出栈了，要么还在栈里，不能是入栈前状态，并且在栈中的顺序是从大到小的(从栈顶往栈底看)，比如出5，那么1，2，3，4要么已经在5之前出了，要么还在栈中（假如1，3，4在栈中，从栈顶往栈底看依次为4，3，1），不能是入栈前的状态。从第一个数字开始扫描，a[i]表示当前出栈的数字，如果有比a[i]大的数字还在栈中，那么就产生矛盾，输出“NO”；
1357：车厢调度(train)
与其邻渊羡渔，不如退而结网
08-11 647
题目描述】有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n≤1000），分别按照顺序编号为1，2，3，…，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁轨，它就不能再回到车站C。...
数据结构与算法-栈
勤于笔记，成于点滴。
11-24 1395
栈又称为堆栈，是一种运算受限定表。说是限定表是由于对于元素的入栈和出栈都在表末尾进行，换言之就是先进后出，其本质就是对表尾部元素进行操作。
队列实现栈_栈_数据结构_队列_
09-30
总结来说，本主题探讨了如何使用队列模拟栈的数据结构，这是数据结构和算法设计中的一个重要技巧。了解和掌握这些基本数据结构及其相互转换的方法，对于提升编程能力和解决问题的能力大有裨益。在实际编程中，灵活...
02栈与队列1
08-03
【栈与队列】是计算机科学中两种基本的数据结构，它们在处理各种计算问题时扮演着重要角色。栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，常用于解决需要回溯或逆序处理的问题，如括号匹配、...
python用栈实现队列
05-30
python用栈实现队列，简单明了易于进一步思考和总结发散思维。
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
最新发布
04-03
### 栈和队列知识点详解 #### 一、栈的定义 栈是一种特殊的线性数据结构，其特点是只允许在一端进行数据的插入和删除操作，遵循“先进后出”(First In Last Out, FILO)的原则。在这个数据结构中，最新加入的数据...
车厢调度算法实验报告
07-03
数据结构车厢调度课程设计实验报告....严蔚敏 吴伟民 米宁主编版本啊
车厢调度问题 ← 栈
hnjzsyjyj的专栏
09-23 553
由于车厢按照编号 1~n 依次入栈，因此，若车厢 x 准备入栈，那么车厢 1 ~ x-1 都已入栈，所以不可能出现栈中元素大于车厢 x 的情况。
20200404栈和队列训练总结
weixin_46434074的博客
04-04 318
1.车厢调度（train) 【题目描述】 有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n≤1000），分别按照顺序编号为1，2，3，…，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B...
T379949 车厢调度
yugaohang的博客
10-09 217
第二次（也是终于AK了好吧）
火车火车！！！！
LuciaX_的博客
02-28 264
PS：本文是记录本人的学习stack的记录有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n
STL详解（二） 栈容器Stack
流年的博客
02-11 3947
一、Stack简介 stack 是容器适配器的一种。要使用 stack，必须包含头文件 <stack>。 stack就是“栈”。栈是一种后进先出的元素序列，访问和删除都只能对栈顶的元素（即最后一个被加入栈的元素）进行，并且元素也只能被添加到栈顶。栈内的元素不能访问。如果一定要访问栈内的元素，只能将其上方的元素全部从栈中删除，使之变成栈顶元素才可以。 容器适配器中的数据是以 LIF...
【题解】车厢调度
weixin_33674976的博客
03-07 1014
题目描述 有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n≤1000），分别按照顺序编号为1，2，3，...，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁轨，它就不能再回到...
车厢调度（信息学奥赛一本通 1357）
anglanjing7414的博客
07-28 590
【问题描述】 有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n<=1000），分别按照顺序编号为1，2，3，…，n。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁...
编译原理5 自底向上语法分析
LI_XIAO_XING的博客
11-10 516
那么既然我的这个新的项目是由这个旧项目推出来的，我肯定要配合这个旧项目，那么接下来的就是beita 和a(beita1可能是空串所以考虑一下a).然后的思路就都是一样的。正常情况下状态栈和符号栈是平的。规约的时候，符号栈把需要规约的符号都弹出去，把与之对应的状态也都弹出去，符号栈再压入对应的非终结符号。实践的时候，其实就是把那些非终结符的OP集算出来，然后看那些产生式，看那些和这个非终结符相邻的终结符，就可以愉快的写出比较了。之前的a只要是个东西都可以得出规约的结论，现在a需要是A的follow集。
循环队列与栈的类型定义与操作
循环队列类型定义是数据...总结来说，循环队列是线性数据结构的一种变体，通过其特有的队列操作规则和循环特性，提供了高效、灵活的数据管理方式。在实际编程中，理解并熟练运用循环队列能够提高代码的效率和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值