A - 数据结构实验之栈与队列一：进制转换
Description
输入一个十进制非负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。
Input
第一行输入需要转换的十进制非负整数；
第二行输入 R。
Output
输出转换所得的 R 进制数。
Sample
Input
1279 8
Output
2377
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
stack<int> s;
int main()
{
int n, r;
cin >> n >> r;
if(n == 0) cout << "0" << endl;// 这个判断还是蛮重要的
while(n){
int x = n % r;
s.push(x);
n /= r;
}
while(!s.empty()){
cout << s.top();
s.pop();
}
return 0;
}B - 数据结构实验之栈与队列四：括号匹配
Description
给你一串字符，不超过50个字符，可能包括括号、数字、字母、标点符号、空格，你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配。
Input
输入数据有多组，处理到文件结束。
Output
如果匹配就输出“yes”，不匹配输出“no”
Sample
Input
sin(20+10)
{[}]
Output
yes no
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
string a;
char b[57];
int main()
{
int top, i;
while(getline(cin, a)){
int l = a.size();
top = 0;
for(i = 0; i < l; i++){
if(a[i] == '(' || a[i] == '[' || a[i] == '{')
b[++top] = a[i];// b[top] = a[i]不是b[0] = a[i]。
if(a[i] == ')' || a[i] == ']' || a[i] == '}'){
if((b[top]=='('&&a[i]==')')||(b[top]=='['&&a[i]==']')||(b[top]=='{'&&a[i]=='}')){
top--;
}
else break;
}
//cout << top;
}
if(top==0&&i==l) cout << "yes" << endl;
else cout << "no" << endl;
}
return 0;
}**b[++top] 可以换成b[top++]，同时下面的b[top]也得改成b[top-1]。
栈的代码：是错的！qwq 应该要清空栈的，但是吧。。em。。。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
stack<char> s;
string str;
int main()
{
int i;
while(getline(cin, str)){
int n = str.size();
for(i = 0; i < n; i++){
if(str[i] == '(' || str[i] == '[' || str[i] == '{'){
s.push(str[i]);
}
if(str[i] == ')' || str[i] == ']' || str[i] == '}'){
if((s.top() == '(' && str[i] == ')') || (s.top() == '[' && str[i] == ']') || (s.top() == '{' && str[i] == '}')){
s.pop();
}
else break;
}
}
if(s.empty() && i == n) cout << "yes" << endl;
else cout << "no" << endl;
}
return 0;
}C - 数据结构实验之栈与队列八：栈的基本操作
Description
堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。
Input
首先输入整数t（1 <= t <= 10），代表测试的组数，以后是 t 组输入。
对于每组测试数据，第一行输入两个正整数 m（1 <= m <= 100)、n（1 <= n <= 1000)，其中m代表当前栈的最大长度，n代表本组测试下面要输入的操作数。 而后的 n 行，每行的第一个字符可能是'P’或者'O’或者'A’；如果是'P’，后面还会跟着一个整数，表示把这个数据压入堆栈；如果是'O’，表示栈顶元素出栈；如果是'A'，表示询问当前栈顶的值'。
Output
对于每组测试数据，根据其中的命令字符来处理堆栈；
（1）对所有的'P'操作，如果栈满输出'F'，否则完成压栈操作；
（2）对所有的'A'操作，如果栈空，则输出'E'，否则输出当时栈顶的值；
（3）对所有的'O'操作，如果栈空，则输出'E'，否则输出栈顶元素的值，并让其出栈；
每个输出占据一行，每组测试数据（最后一组除外）完成后，输出一个空行。
Sample
Input
2 5 10 A P 9 A P 6 P 3 P 10 P 8 A P 2 O 2 5 P 1 P 3 O P 5 A
Output
E 9 8 F 8 3 5
Hint
建议： 用串的方式（%s）读入操作字符。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
string str;
int main()
{
ios::sync_with_stdio(false);
int t;
cin >> t;
while(t--){
stack<int> s;// ！！！
int m, n;
cin >> m >> n;
while(n--){
cin >> str;
if(str == "P"){
int x;
cin >> x;
int z = s.size();
if(z >= m) cout << "F" << endl;
else s.push(x);
}
else if(str == "A"){
if(s.empty()) cout << "E" << endl;
else cout << s.top() << endl;
}
else if(str == "O"){
if(s.empty()) cout << "E" << endl;
else {
cout << s.top() << endl;
s.pop();
}
}
}
if(t != 0) cout << endl;
}
return 0;
}D - 数据结构实验之栈与队列九：行编辑器
Description
一个简单的行编辑程序的功能是：接受用户从终端输入的程序或数据，并存入用户的数据区。
由于用户在终端上进行输入时，不能保证不出差错，因此，若在编辑程序中，“每接受一个字符即存入用户数据区”的做法显然不是最恰当的。较好的做法是，设立一个输入缓冲区，用以接受用户输入的一行字符，然后逐行存入用户数据区。允许用户输入出差错，并在发现有误时可以及时更正。例如，当用户发现刚刚键入的一个字符是错的时，可补进一个退格符"#"，以表示前一个字符无效；
如果发现当前键入的行内差错较多或难以补救，则可以键入一个退行符"@"，以表示当前行中的字符均无效。
如果已经在行首继续输入'#'符号无效。
Input
输入多行字符序列，行字符总数（包含退格符和退行符）不大于250。
Output
按照上述说明得到的输出。
Sample
Input
whli##ilr#e(s#*s) outcha@putchar(*s=#++);
Output
while(*s) putchar(*s++);
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
char s[257];
char b[257];
int main()
{
int top;
while(cin >> s){
top = 0;
int n = strlen(s);
for(int i = 0; i < n; i++){
if(s[i] == '#'){
if(top != 0) top--;
}
else if(s[i] == '@'){
if(top != 0){
while(top != 0) top--;
}
}
else b[top++] = s[i];// 这里top是从0开始的 b[0]、b[1]、b[2]……
}
for(int i = 0; i < top; i++){
if(i == top - 1) cout << b[i] << endl;
else cout << b[i];
}
}
return 0;
}**哈哈哈现在对top++和++top之类的贼敏感
E - 传纸条
Description
传纸条是一种在课堂上传递信息的老方法，虽然现在手机短信和QQ聊天越来越普及，但是手写的信息会让人感到一种亲切感。对许多学生而言，在学校里传递一些私秘性的信息是一种令人兴奋的打发时光的方式，特别是在一些令人厌烦的课堂上。
XX 和 YY 经常在自习课的时候传纸条来传递一些私密性的信息。但是他们的座位相隔比较远，传纸条要通过其他人才能到达对方。在传递过程中，难免会有一些好奇心比较强的同学偷看纸条的内容。所以他们想到了一个办法，对纸条内容进行加密。
加密规则很简单：多次在信息的任意位置随意的添加两个相同的字母。
由于使用英文交流显得比较高端，所以他们的纸条内容只有英文。
现在给你加密后的信息，请你还原出原始的内容。
Input
输入数据的第一行为一个正整数 T(T ≤ 30)，表示共有 T 组测试数据。
接下来 T 行，每行为一个字符串，字符串仅包含小写英文字母，且保证原始字符串中不包含相邻两个相同的字母，字符串长度不超过200000。
Output
每组数据输出一行字符串，表示还原后的内容。
Sample
Input
1
ssilofaafveuuu
Output
iloveu
Hint
删除掉aa后，又出现了ff，ff也要删除掉。
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
stack<char> a;
char s[N];
int main()
{
int t;
cin >> t;
while(t--){
int top = 0;
cin >> s;
int n = strlen(s);
for(int i = 0; i < n; i++){
if(!a.empty() && s[i] == a.top()){// 栈不是空的才能pop
a.pop();
}
else a.push(s[i]);
}
int len = a.size();
s[len] = '\0';// 字符串数组'\0'结尾
int m = len - 1;
while(!a.empty()){
s[m--] = a.top();
a.pop();
}
cout << s << endl;
}
return 0;
}**直接从栈顶输出的话，是反过来的，所以还是要存到数组里再输出
F - 数据结构实验之栈与队列二：一般算术表达式转换成后缀式
Description
对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。
Input
输入一个算术表达式，以‘#’字符作为结束标志。
Output
输出该表达式转换所得到的后缀式。
Sample
Input
a*b+(c-d/e)*f#
Output
ab*cde/-f*+
G - 数据结构实验之栈与队列五：下一较大值（一）
Description
对于包含n（1<=n<=1000）个整数的序列，对于序列中的每一元素，在序列中查找其位置之后第一个大于它的值，如果找到，输出所找到的值，否则，输出-1。
Input
输入有多组，第一行输入t（1<=t<=10），表示输入的组数；
以后是 t 组输入：每组先输入n，表示本组序列的元素个数，之后依次输入本组的n个元素。
Output
输出有多组，每组之间输出一个空行（最后一组之后没有）；
每组输出按照本序列元素的顺序，依次逐行输出当前元素及其查找结果，两者之间以-->间隔。
Sample
Input
2 4 12 20 15 18 5 20 15 25 30 6
Output
12-->20 20-->-1 15-->18 18-->-1 20-->25 15-->25 25-->30 30-->-1 6-->-1
Hint
本题的数据量小、限时要求低，可以不用栈来完成。
**不用栈：
#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
int a[N];
int main()
{
int t;
cin >> t;
while(t--){
int n;
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i];
}
int i, j;
for(i = 0; i < n; i++){
printf("%d-->", a[i]);
for(j = i + 1; j < n; j++){
if(a[j] > a[i]){
printf("%d\n", a[j]);
break;
}
}
if(j == n){
printf("-1\n");
}
}
if(t != 0){
cout << endl;
}
}
return 0;
}**用栈：
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
stack<int> s;
int a[N], b[N];
int main()
{
int t;
cin >> t;
while(t--){
while(!s.empty()) s.pop();// 清空栈
int n;
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
b[n-1] = -1;
s.push(a[n-1]);
for(int i = n - 2; i >= 0; i--){
b[i] = -1;// 兜底，如果后面没有比自己大的，就输出-1
while(!s.empty() && a[i] >= s.top()) s.pop();
if(!s.empty()) b[i] = s.top();
s.push(a[i]);// 每一个都得进栈，，只是不一定能留下来。。。
}
for(int i = 0; i < n; i++){
printf("%d-->%d\n", a[i], b[i]);
}
if(t != 0) cout << endl;
}
return 0;
}**原来可以这样清空栈，漂亮啊！！
H - 数据结构实验之栈与队列六：下一较大值（二）
Description
对于包含n（1<=n<=100000）个整数的序列，对于序列中的每一元素，在序列中查找其位置之后第一个大于它的值，如果找到，输出所找到的值，否则，输出-1。
Input
输入有多组，第一行输入t（1<=t<=10），表示输入的组数；
以后是 t 组输入：每组先输入n，表示本组序列的元素个数，之后依次输入本组的n个元素。
Output
输出有多组，每组之间输出一个空行（最后一组之后没有）；
每组输出按照本序列元素的顺序，依次逐行输出当前元素及其查找结果，两者之间以-->间隔。
Sample
Input
2 4 12 20 15 18 5 20 15 25 30 6
Output
12-->20 20-->-1 15-->18 18-->-1 20-->25 15-->25 25-->30 30-->-1 6-->-1
Hint
本题数据量大、限时要求高，须借助栈来完成。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
stack<int> s;
int a[N], b[N];
int main()
{
int t;
cin >> t;
while(t--){
while(!s.empty()) s.pop();// 清空栈
int n;
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
b[n-1] = -1;
s.push(a[n-1]);
for(int i = n - 2; i >= 0; i--){
b[i] = -1;// 兜底，如果后面没有比自己大的，就输出-1
while(!s.empty() && a[i] >= s.top()) s.pop();
if(!s.empty()) b[i] = s.top();
s.push(a[i]);// 每一个都得进栈，，只是不一定能留下来。。。
}
for(int i = 0; i < n; i++){
printf("%d-->%d\n", a[i], b[i]);
}
if(t != 0) cout << endl;
}
return 0;
}I - 数据结构实验之队列一:排队买饭
Description
中午买饭的人特多,食堂真是太拥挤了,买个饭费劲,理工大的小孩还是很聪明的,直接奔政通超市,哈哈,确实,政通超市里面也卖饭,有好几种菜,做的比食堂好吃多了,价格也不比食堂贵,并且买菜就送豆浆,吸引了不少童鞋。所以有时吧，人还是很多的，排队是免不了的，悲剧的是超市只有两个收银窗口。
问题是这样的：开始有两队人在排队，现在咱们只研究第一队，现在我们给每个人一个编号，保证编号各不相同，排在前面的人买完饭就走了，有些人挑完饭就排在后面等待付款，还有一些人比较聪明，看到另一个队人比较少，直接离开这个队到另一个队去了。我要问的是队的总人数和某个位置上人的编号。
Input
首先输入一个整数m(m<10000)，代表当前有m个人，第二行输入m个数，代表每个人的编号，第三行输入一个整数n(n<10000)，代表队列变动和询问一共n次，以后n行，JOIN X表示编号为X（保证与以前的编号不同）的人加入；LEAVE Y表示第Y（Y小于当前队列长度）个位置 上的人离队 ；ASK Z（Z小于当前队列长度）表示询问第Z个位置上的人的编号；FINISH D表示有D个人买完饭离开了;LENGTH表示询问队列的长度 。保证所有数据在int 范围内.
Output
对每个询问输出相应的答案，每个答案占一行。
Sample
Input
3
1 2 3
6
JOIN 4
ASK 2
LEAVE 2
LENGTH
FINISH 2
LENGTH
Output
2
3
1
Hint
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
int q[N];
string s;
int main()
{
int m, x;
cin >> m;
for(int i = 0; i < m; i++){
cin >> q[i];
}
int n, y;
cin >> n;
for(int i = 0; i < n; i++){
cin >> s;
if(s == "JOIN"){
cin >> y;
q[m++] = y;// 这里是q[m]、q[m+1]、q[m+2]…… 队伍在加长
}
else if(s == "ASK"){
cin >> y;
cout << q[y-1] << endl;// 编号和位置差一位
}
else if(s == "LEAVE"){
cin >> y;
for(int j = y - 1; j < m - 1; j++){
q[j] = q[j+1];// 不理解的话可以画个图看看
}
m--;// 离开一个人
}
else if(s == "FINISH"){
cin >> y;
for(int j = 0; j < y; j++){
for(int k = 0; k < m - y + 1; k++){
q[k] = q[k+1];
}
}
m -= y;// 离开了y个人（前y个）
}
else if(s == "LENGTH") cout << m << endl;
}
return 0;
}**我觉得这个题是为了让我们熟悉队列的原理
J - 双向队列
Description
想想双向链表……双向队列的定义差不多，也就是说一个队列的队尾同时也是队首；两头都可以做出队，入队的操作。
现在给你一系列的操作，请输出最后队列的状态；
命令格式：
LIN X X表示一个整数，命令代表左边进队操作；
RIN X 表示右边进队操作；
ROUT
LOUT 表示出队操作；
Input
第一行包含一个整数M(M<=10000)，表示有M个操作；
以下M行每行包含一条命令；
命令可能不合法，对于不合法的命令，请在输出中处理；
Output
输出的第一行包含队列进行了M次操作后的状态，从左往右输出，每两个之间用空格隔开；
以下若干行处理不合法的命令（如果存在）；
对于不合法的命令，请输出一行X ERROR
其中X表示是第几条命令；
Sample
Input
8 LIN 5 RIN 6 LIN 3 LOUT ROUT ROUT ROUT LIN 3
Output
3 7 ERROR
Hint
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
deque<int> q;// 创建双向队列
string s;
int a[N];
int main()
{
while(!q.empty()) q.pop_front();// 清空队列
int m;
cin >> m;
for(int i = 1; i <= m; i++){
cin >> s;
int x;
if(s == "LIN"){
cin >> x;
q.push_front(x);// 在左边（队首）存入x
}
else if(s == "RIN"){
cin >> x;
q.push_back(x);// 在右边（队尾）存入x
}
else if(s == "LOUT"){
if(!q.empty()) q.pop_front();// 非空才能删数嘛
else a[i]++;// 起到标记作用，标记错误的那一步
}
else if(s == "ROUT"){
if(!q.empty()) q.pop_back();
else a[i]++;
}
}
cout << q.front();
q.pop_front();
while(!q.empty()){
cout << " " << q.front();
q.pop_front();
}// 每两个数之间有一个空格。。最后一个数后面没有。
cout << endl;
for(int i = 1; i <= m; i++){
if(a[i]) cout << i << " " << "ERROR" << endl;
}
return 0;
}**1、这里的a[i]++的意义：起初a[N] = {0}，即每一个a[i] = 0，a[i]++的意思是使a[i] = 1
对应着后面的if(a[i])。（也要注意开始的for循环要从1开始哦~）
2、输出格式！！真的可恶！！！
K - 数据结构实验之栈与队列十一：refresh的停车场
Description
refresh最近发了一笔横财，开了一家停车场。由于土地有限，停车场内停车数量有限，但是要求进停车场的车辆过多。当停车场满时，要进入的车辆会进入便道等待，最先进入便道的车辆会优先
进入停车场，而且停车场的结构要求只出去的车辆必须是停车场中最后进去的车辆。现告诉你停车场容量N以及命令数M，以及一些命令（Add num 表示车牌号为num的车辆要进入停车场或便道，
Del 表示停车场中出去了一辆车，Out 表示便道最前面的车辆不再等待，放弃进入停车场）。假设便道内的车辆不超过1000000.
Input
输入为多组数据，每组数据首先输入N和M（0＜ ｎ，ｍ ＜200000），接下来输入M条命令。
Output
输入结束后，如果出现停车场内无车辆而出现Del或者便道内无车辆而出现Out,则输出Error,否则输出停车场内的车辆，最后进入的最先输出，无车辆不输出。
Sample
Input
2 6 Add 18353364208 Add 18353365550 Add 18353365558 Add 18353365559 Del Out
Output
18353365558 18353364208
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int MAXN = 0x3f3f3f3f;
typedef long long ll;
string str;
string num;
stack<string> s;
deque<string> q;
int main()
{
int n, m;
while(cin >> n >> m){
while(!s.empty()) s.pop();// 清空栈
while(!q.empty()) q.pop_front();// 清空队列
int f = 0;
while(m--){
cin >> str;
if(str == "Add"){
cin >> num;
if(s.size() < n) s.push(num);
else q.push_back(num);
}
else if(str == "Del"){
if(!s.empty()){
s.pop();
if(!q.empty()){
s.push(q.front());
q.pop_front();// 这里别忘了
}
}
else f = 1;
}
else if(str == "Out"){
if(!q.empty()) q.pop_front();
else f = 1;
}
}
if(f) cout << "Error" << endl;
else{
while(!s.empty()){
cout << s.top() << endl;
s.pop();
}
}
}
return 0;
}**建议别整什么幺蛾子。。if……else……对应着来就得了
L - 离散事件模拟-银行管理
Description
现在银行已经很普遍，每个人总会去银行办理业务，一个好的银行是要考虑 平均逗留时间的，即： 在一定时间段内所有办理业务的人员逗留的时间的和/ 总的人数。逗留时间定义为 人员离开的时间减去人员来的时间。银行只有考虑了这一点，我们在办理业务的时候，才不会等太多的时间。
为了简化问题，我们认为银行只有一号窗口和二号窗口可以办理业务 ，并且在时间范围是12<=time<=18,即从中午十二点到晚上十八点，输入数据采用分钟即0代表中午12点，60代表下午一点，90代表下午一点半… 这样time>=0&&time<=360, 如果来的时间超出这个时间段不接受（办理时间不受限制）。每个人到达的时间都不一样。顾客到达的时候，总是前往人数少的那个窗口。如果人数相当或者两个窗口都没有人总是前往1号窗口。请计算平均逗留时间=总逗留的分钟数/总的人数。
Input
第一行一个整数t(0 < t <= 100), 代表输入的组数。
对于每一组输入一个整数n (0 < n <= 100)，代表有n个人。然后是n行，每行有两个数据 x 与 y。 x代表顾客到达时间，y代表办理业务需要的时间。x, y 为整数（0 <= x <= 360）(y > 0 && y <= 15)。数据保证按顾客来的先后顺序输入。
Output
对于每组数据输出平均逗留时间，保留两位小数。
Sample
Input
1 1 60 10
Output
10.00
1341
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
