NEUQ-acm预备队训练Week3-线性表

1. 栈的应用——括号匹配、表达式计算

栈的特点：先进后出，只能在栈顶删除和插入

习题 P1449 后缀表达式

题目描述

所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。

如：$\text{3*(5-2)+7}$ 对应的后缀表达式为：$\text{3.5.2.-*7.+@}$。在该式中，@ 为表达式的结束符号。. 为操作数的结束符号。

输入格式

输入一行一个字符串 $s$，表示后缀表达式。

输出格式

输出一个整数，表示表达式的值。

样例输入 #1

3.5.2.-*7.+@

样例输出 #1

16

提示

数据保证，$1\le |s|\le 50$，答案和计算过程中的每一个值的绝对值不超过 $10^9$。

思路

如果是操作数，入栈
如果是操作符$<op>$ ，则从栈中依次取出两个数$X,Y$，做运算$Y<op>X$，再将计算结果入栈
当所有表达式的项扫描完毕，栈顶存放的即表达式的结果

代码

#include 
using namespace std;
long long shu[55];
int main(){
    stack<long long> q;
    int i = 0;
    while(1){
        char x;
        cin >> x;
        if(x=='@')  break;
        if(x=='.'){
            long long n=0;
            for(int j=i-1; j >=0; j--){
                n+=shu[j]*pow(10,i-j-1);
            }
            q.push(n);
            i=0;
        }
        if(x>='0' && x<='9'){
            shu[i++]=x-'0';
        }
        if(x=='+' || x=='-' || x=='*' || x=='/'){
            long long b=q.top();  q.pop();
            long long a=q.top();  q.pop();
            switch(x){
            case '+':  q.push(a+b);  break;
            case '-':  q.push(a-b);  break;
            case '*':  q.push(a*b);  break;
            case '/':  q.push(a/b);  break;
            }
        }
        
    }
    long long y=q.top();
    cout << y << endl;

}

注意点：（1）直接 long long
(2) 以 .为操作数结束标志，即操作数可以不仅仅是一位数，所以要有一个转换计算出操作数

习题 P1241 括号序列

题目描述

定义如下规则：

1. 空串是「平衡括号序列」
2. 若字符串 $S$ 是「平衡括号序列」，那么 $\text{[}S\text{]}$ 和 $\text{(}S\text{)}$ 也都是「平衡括号序列」
3. 若字符串 $A$ 和 $B$ 都是「平衡括号序列」，那么 $AB$（两字符串拼接起来）也是「平衡括号序列」。

例如，下面的字符串都是平衡括号序列：

()，[]，(())，([])，()[]，()[()]

而以下几个则不是：

(，[，]，)(，())，([()

现在，给定一个仅由 (，)，[，]构成的字符串 $s$，请你按照如下的方式给字符串中每个字符配对：

1. 从左到右扫描整个字符串。
2. 对于当前的字符，如果它是一个右括号，考察它与它左侧离它最近的未匹配的的左括号。如果该括号与之对应（即小括号匹配小括号，中括号匹配中括号），则将二者配对。如果左侧未匹配的左括号不存在或与之不对应，则其配对失败。

配对结束后，对于 $s$ 中全部未配对的括号，请你在其旁边添加一个字符，使得该括号和新加的括号匹配。

输入格式

输入只有一行一个字符串，表示 $s$。

输出格式

输出一行一个字符串表示你的答案。

样例输入 #1

([()

样例输出 #1

()[]()

样例输入 #2

([)

样例输出 #2

()[]()

提示

数据规模与约定

对于全部的测试点，保证 $s$ 的长度不超过 100，且只含 (，)，[，] 四个字符。

思路

标记有匹配的括号，顺序遍历，被标记的直接输出，未标记的输出对应的一对括号
那怎么标记呢？
依旧顺序遍历：
（1）遇到左括号，入栈
（2）遇到右括号，查找一下前面有无匹配，（即看栈顶是否为匹配的），如果有匹配，标记这个右括号，同时，还要再标记与之匹配的左括号
这样就标记完成啦~

代码

#include 
using namespace std;
int s[105];
int main(){
    stack<char> q;
    string c;
    cin >> c;
    int len=c.length();
    for(int i=0; i < len; i++){
        if(c[i]=='(' || c[i]=='[') q.push(c[i]);
        if(c[i]==')'){
            if(q.empty())  continue;
            else {
                if(q.top()=='('){
                    q.pop(),s[i]=1;
                    for(int j=i-1; j>=0; j--){
                        if(c[j]=='(' && s[j]!=1) {s[j]=1; break;}
                    }
                } 
                else continue;
            }
        }
        if(c[i]==']'){
            if(q.empty())  continue;
            else {
                if(q.top()=='[') {
                    q.pop(),s[i]=1;
                    for(int j = i-1; j >= 0; j--){
                        if(c[j]=='[' && s[j]!=1){s[j]=1; break;}
                    }
                }
                else continue;
            }
        }
    }
    //cout << len << endl;
    for(int i = 0; i < len; i++){
       // cout << s[i]  << endl;
        if(s[i]==1)  cout << c[i];
        else{
            switch(c[i]){
                case '(': cout << "()";  break;
                case ')': cout << "()";  break;
                case '[': cout << "[]";  break;
                case ']': cout << "[]";  break;
            }
    }
    
}
}

犯错记录：
（1）忘记标记与右括号匹配的左括号
（2）第一次做时尝试标记没有匹配的括号，这样发现栈中剩余的不好标记，考虑不周全
（3）其实用数组模拟栈更好，可直接标记被匹配的左括号（下标即位置），而我选择栈，需要再套循环，倒序搜索前面第一个找到的未被标记的匹配括号。麻烦了许多~

2 动态数组——vector应用

vector可理解为数组，但与数组相比，vector是一个可以不用在初始化时就必须制定大小的数组，即长度可变的数组。
vector初始化：

vector <char> v; // vector默认长度是0， 类型可以是c++的标准类型，也可以是自己定义的类或结构体
vector <int> v(N); // 效果类似int v[N];但是N可以是变量
vector <int> v(N, i); // 可变数组最开始有N个元素，每个元素的值是i,i可以省略不写
vector < vector<int> > v; // 定义一个int类型的vector二维数组，要注意的是，> > 需分开写，有的编译器不分开会当成右移符合>>

常用操作：

vector <int> a;
a.push_back(5);
// 在vector末尾添加元素，自动增加vector的长度
a.resize(5);
// 给vector重新分配内存为5
a.pop_back();
//删除a向量的最后一个元素
a.size();
//返回a中元素的个数
a.back();
//返回a的最后一个元素
a.front();
//返回a的第一个元素
a[i];
//返回a的第i元素,当且仅当a存在

习题 P3613【深基15.例2】寄包柜

题目描述

超市里有 $n(1\le n\le 10^5)$ 个寄包柜。每个寄包柜格子数量不一，第 $i$ 个寄包柜有 $a_i(1\le a_i\le 10^5)$ 个格子，不过我们并不知道各个 $a_i$ 的值。对于每个寄包柜，格子编号从 1 开始，一直到 $a_i$。现在有 $q(1\le q\le 10^5)$ 次操作：

• 1 i j k：在第 $i$ 个柜子的第 $j$ 个格子存入物品 $k(0\le k\le 10^9)$。当 $k=0$ 时说明清空该格子。
• 2 i j：查询第 $i$ 个柜子的第 $j$ 个格子中的物品是什么，保证查询的柜子有存过东西。

已知超市里共计不会超过 $10^7$ 个寄包格子，$a_i$ 是确定然而未知的，但是保证一定不小于该柜子存物品请求的格子编号的最大值。当然也有可能某些寄包柜中一个格子都没有。

输入格式

第一行 2 个整数 $n$ 和 $q$，寄包柜个数和询问次数。

接下来 $q$ 个整数，表示一次操作。

输出格式

对于查询操作时，输出答案，以换行隔开。

样例输入 #1

5 4
1 3 10000 118014
1 1 1 1
2 3 10000
2 1 1

样例输出 #1

118014
1

提示

$\text{upd 2022.7.26}$：新增加一组 Hack 数据。

思路

建一个a[1e5+5][1e5+5] 的二维数组，按下标存取 显然，是不可以的，编译都编译不了
回头看，一共格子数远远小于$10^{10}$，格子利用率不高，考虑动态申请空间
使用结构体$+$vector

struct gui{
    int i=0;  //每个柜子中存放了东西的格子数
    vector<long long> a,b;  //a用于存格子的下标，b用于存东西
}g[Max];

每当碰到1（存放），i++，a和b加入新数据
碰到2（查询），倒序循环该柜子存放了东西的格子，因为靠后的是更新过的格子

代码

#include 
#include 
using namespace std;
const int Max = 1e5 + 5;
struct gui{
    int i=0;
    vector<long long> a,b;
}g[Max];

void In(){
    int x,y;
    long long k;
    cin >> x >> y >> k;
    g[x].i++;
    g[x].a.push_back(y);
    g[x].b.push_back(k);
}
int main(){
    int n,q;
    cin >> n >> q;
    for(int i = 0; i < q; i++){
        int flag;
        cin >> flag;
       if(flag==1){
            In();
        }
        else {
            int x,y;
            cin >> x >> y;
            for(int j=g[x].i-1; j>=0; j--){
                if(g[x].a[j]==y){
                    cout << g[x].b[j] << endl;
                    break;
                }
            }
        }
    }
}

学这的时候老师讲的快，还以为没什么用呢，原来这么有用啊~~~

4. 链表

链表的好处：插入和删除方便，在保持原有顺序不变下，链表的插入和删除不需要移位
另外，为了能够寻找到某一位置的前后，采用双向链表操作更简便

习题 P1160 队列安排

题目描述

一个学校里老师要将班上 $N$ 个同学排成一列，同学被编号为 $1\sim N$，他采取如下的方法：

1. 先将 $1$ 号同学安排进队列，这时队列中只有他一个人；

2. $2-N$ 号同学依次入列，编号为 $i$ 的同学入列方式为：老师指定编号为 $i$ 的同学站在编号为 $1\sim (i-1)$ 中某位同学（即之前已经入列的同学）的左边或右边；

3. 从队列中去掉 $M(M<N)$ 个同学，其他同学位置顺序不变。

在所有同学按照上述方法队列排列完毕后，老师想知道从左到右所有同学的编号。

输入格式

第 $1$ 行为一个正整数 $N$，表示了有 $N$ 个同学。

第 $2\sim N$行，第 $i$ 行包含两个整数 $k,p$，其中 $k$ 为小于 $i$ 的正整数，$p$ 为 $0$ 或者 $1$。若 $p$ 为$ 0$，则表示将 $i$ 号同学插入到 $k$ 号同学的左边，$p$ 为 $1$ 则表示插入到右边。

第 $N+1$ 行为一个正整数 $M$，表示去掉的同学数目。

接下来 $M$ 行，每行一个正整数 $x$，表示将 $x$ 号同学从队列中移去，如果 $x$ 号同学已经不在队列中则忽略这一条指令。

输出格式

$1$ 行，包含最多 $N$ 个空格隔开的正整数，表示了队列从左到右所有同学的编号，行末换行且无空格。

样例输入 #1

4
1 0
2 1
1 0
2
3
3

样例输出 #1

2 4 1

提示

样例解释：

将同学 $2$ 插入至同学 $1$ 左边，此时队列为：

2 1

将同学 $3$ 插入至同学 $2$ 右边，此时队列为：

2 3 1

将同学 $4$ 插入至同学 $1$ 左边，此时队列为：

2 3 4 1

将同学 $3$ 从队列中移出，此时队列为：

2 4 1

同学 $3$ 已经不在队列中，忽略最后一条指令

最终队列：

2 4 1

数据范围

对于 $20\%$ 的数据，有 $1\le N\le 10$；

对于 $40\%$ 的数据，有 $1\le N\le 1000$；

对于 $100\%$ 的数据，有 $1\le N,M\le 100000$。

思路

先开始想到静态链表data域存编号，发现还需要循环来查找编号，有些费时，另外左插入有些困难；
之后想到双向循环链表，有左右link域，左右插入都比较方便
思路就有了：
（1）存放
把编号直接当作下标（从1开始），就不需要data域了，左link域存排在左边的同学的编号（即下标），右link域存排在右边的同学的编号，左右无同学则存0；
（2）删除
记删除的同学的编号为$i$；
然后做三步：$i$的左同学右link域改为$i$右同学编号； $i$ 右同学左link域改为$i$ 左同学编号； $i$同学拿出来（即左右link域为0）；
（3）输出
很显然，只要找到排在最前面的同学，之后依次都能找到并输出
那么排在最左边的同学怎么找呢？
不难发现，左边的同学左link域为0，右link域不为0，所以只要从左到右按下标循环一边就找到了。
但是为什么不能在存放的时候就记录一下最左端的下标呢，这样岂不是少一次循环，所以加入了front，当左插入时，如果被插的是头，那么就更新一下front，否则无需改动。
思路很清楚了，今天的代码就写的快啦~

代码

#include 
using namespace std;
int N,M;
const int Max = 1e5+5;
int front=1, num=1;
struct Node{
    int l=0;
    int r=0;
}stu[Max];
void input(int i, int k, int p){
    if(p==0){
        if(k==front){
            stu[front].l=i;
            stu[i].r=front;
            front=i;
            //cout << front;
        }
        else{
            stu[stu[k].l].r=i;
            stu[i].l=stu[k].l;
            stu[i].r=k;
            stu[k].l=i;
        }
    }
    else{
        if(stu[k].r==0){
            stu[k].r=i;
            stu[i].l=k;
        }
        else{
            stu[stu[k].r].l=i;
            stu[i].r=stu[k].r;
            stu[i].l=k;
            stu[k].r=i;
        }
    }
}
void remove(int x){
    if(stu[x].l==0 && stu[x].r==0){}
    else{
        if(stu[x].l==0){
            front=stu[x].r;
            stu[x].r=0;
        }
        else if(stu[x].r==0) {
            stu[stu[x].l].r=0;
            stu[x].l=0;
        }
        else{
            stu[stu[x].l].r=stu[x].r;
            stu[stu[x].r].l=stu[x].l;
            stu[x].l=0;
            stu[x].r=0;
        }
        num--;
    }
}
void output(){
    cout << front << " ";
    for(int i = 1; i < num; i++){
        cout << stu[front].r << " ";
        front=stu[front].r;
    }
}
int main(){
    cin >> N;
    for(int i = 2; i <= N; i++){
        int k,p;
        cin >> k >> p;
        input(i,k,p);
    }
    num=N;
    cin >> M;
    for(int i = 0; i < M; i++){
        int x;
        cin >> x;
        remove(x);
    }
    output();
}

这道题的代码一次成功，没有出错欸~~~