【深基15.例2】寄包柜
本文包括三个例题以及vector容器，链表，栈的基本使用方法
题目描述
超市里有 n ( 1 ≤ n ≤ 1 0 5 ) n(1\le n\le10^5) n(1≤n≤105) 个寄包柜。每个寄包柜格子数量不一，第 i i i 个寄包柜有 a i ( 1 ≤ a i ≤ 1 0 5 ) a_i(1\le a_i\le10^5) ai(1≤ai≤105) 个格子，不过我们并不知道各个 a i a_i ai 的值。对于每个寄包柜，格子编号从 1 开始，一直到 a i a_i ai。现在有 q ( 1 ≤ q ≤ 1 0 5 ) q(1 \le q\le10^5) q(1≤q≤105) 次操作：
1 i j k：在第 i i i 个柜子的第 j j j 个格子存入物品 k ( 0 ≤ k ≤ 1 0 9 ) k(0\le k\le 10^9) k(0≤k≤109)。当 k = 0 k=0 k=0 时说明清空该格子。2 i j：查询第 i i i 个柜子的第 j j j 个格子中的物品是什么，保证查询的柜子有存过东西。
已知超市里共计不会超过 1 0 7 10^7 107 个寄包格子， a i a_i ai 是确定然而未知的，但是保证一定不小于该柜子存物品请求的格子编号的最大值。当然也有可能某些寄包柜中一个格子都没有。
输入格式
第一行 2 个整数 n n n 和 q q q，寄包柜个数和询问次数。
接下来 q q q 个整数，表示一次操作。
输出格式
对于查询操作时，输出答案，以换行隔开。
样例 #1
样例输入 #1
5 4
1 3 10000 118014
1 1 1 1
2 3 10000
2 1 1
样例输出 #1
118014
1
提示
upd 2022.7.26 \text{upd 2022.7.26} upd 2022.7.26：新增加一组 Hack 数据。
这个题笔者第一反应是想到了二维数组，无奈二维数组空间复杂度太高，过不了
因此笔者想到了用map存储对应的柜子，格子和物品k，可以定义一个map<pair<int,int>,int>p;
pair<int,int>q;其中q用来将柜子和格子整合到一起为一个类型，p[q]表示对应柜子与格子所装的物品
AC代码如下
#include <utility>
#include <map>
#include <iostream>
using namespace std;
int x;
map<pair<int, int>, int> p;
int main()
{
int n, q;
cin >> n >> q;
for (int i = 0; i < q; i++)
{
int o;
cin >> o;
if (o == 1)
{
pair<int, int> q; //整合存放物品的柜子与格子为一个类型
cin >> q.first >> q.second >> x;
if (x != 0)
p[q] = x;
else
p[q] = 0;
}
else if (o == 2)
{
pair<int, int> q1;
cin >> q1.first >> q1.second;
cout << p[q1] << endl; //搜索对应柜子中对应格子所存的物品并输出
}
}
}
括号序列
题目描述
定义如下规则：
- 空串是「平衡括号序列」
- 若字符串 S S S 是「平衡括号序列」，那么 [ S ] \texttt{[}S\texttt] [S] 和 ( S ) \texttt{(}S\texttt) (S) 也都是「平衡括号序列」
- 若字符串 A A A 和 B B B 都是「平衡括号序列」，那么 A B AB AB（两字符串拼接起来）也是「平衡括号序列」。
例如，下面的字符串都是平衡括号序列：
()，[]，(())，([])，()[]，()[()]
而以下几个则不是：
(，[，]，)(，())，([()
现在，给定一个仅由 (，)，[，]构成的字符串
s
s
s，请你按照如下的方式给字符串中每个字符配对：
- 从左到右扫描整个字符串。
- 对于当前的字符，如果它是一个右括号，考察它与它左侧离它最近的未匹配的的左括号。如果该括号与之对应（即小括号匹配小括号，中括号匹配中括号），则将二者配对。如果左侧未匹配的左括号不存在或与之不对应，则其配对失败。
配对结束后，对于 s s s 中全部未配对的括号，请你在其旁边添加一个字符，使得该括号和新加的括号匹配。
输入格式
输入只有一行一个字符串，表示 s s s。
输出格式
输出一行一个字符串表示你的答案。
样例 #1
样例输入 #1
([()
样例输出 #1
()[]()
样例 #2
样例输入 #2
([)
样例输出 #2
()[]()
提示
数据规模与约定
对于全部的测试点，保证
s
s
s 的长度不超过 100，且只含 (，)，[，] 四个字符。
这个题如果只从前往后看可能比较麻烦，因为不知道左括号与后面的哪一个右括号匹配或者没有匹配结果
因此可以采取逆向思维
只找右括号，然后向左扫描到头，找到第一个左括号，如果左括号匹配则标记，不匹配则不标记
输出是标记的括号直接输出，没标记的括号则补充成对输出
AC代码如下
#include <iostream>
using namespace std;
int a[105];
int main()
{
int i, j;
string s;
cin >> s;
for (i = 0; i < s.length(); i++)
{
if (s[i] == ')') //如果找到了右括号
{
for (j = i - 1; j >= 0; j--) //从右括号的左边向左找起
{
if (s[j] == '(' && a[j] == 0) //如果找到了未匹配过的正确的左括号
{
a[i] = a[j] = 1; //就将这对括号标记为匹配过
break;
}
else if (s[j] == '[' && a[j] == 0) //如果首先找到了未匹配过的错误的左括号，就跳出循环不再找了，不做标记
break;
}
}
else if (s[i] == ']') //同上
{
for (j = i - 1; j >= 0; j--)
{
if (s[j] == '[' && a[j] == 0)
{
a[i] = a[j] = 1;
break;
}
else if (s[j] == '(' && a[j] == 0)
break;
}
}
}
for (i = 0; i < s.length(); i++)
{
if (a[i] == 0)
{
if (s[i] == '(' || s[i] == ')') //如果时未匹配括号，则输出成对括号
cout << "()";
else
cout << "[]";
}
else
cout << s[i]; //若是匹配括号，则直接输出
}
}
后缀表达式
题目描述
所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。
如：
3*(5-2)+7
\texttt{3*(5-2)+7}
3*(5-2)+7 对应的后缀表达式为：
3.5.2.-*7.+@
\texttt{3.5.2.-*7.+@}
3.5.2.-*7.+@。在该式中，@ 为表达式的结束符号。. 为操作数的结束符号。
输入格式
输入一行一个字符串 s s s，表示后缀表达式。
输出格式
输出一个整数，表示表达式的值。
样例 #1
样例输入 #1
3.5.2.-*7.+@
样例输出 #1
16
提示
数据保证， 1 ≤ ∣ s ∣ ≤ 50 1 \leq |s| \leq 50 1≤∣s∣≤50，答案和计算过程中的每一个值的绝对值不超过 1 0 9 10^9 109。
这个题用栈比较合适，不算太难
AC代码如下
#include <iostream>
#include <math.h>
using namespace std;
int num; //用来计算数字位数
int h = 0;
int a[55];
int linshi[55]; //定义临时数组，用来储存多位数
int main()
{
string s;
int top = 0; //栈顶
int temp[10]; //存放每一位数
int value = 0; //每步计算的数值
cin >> s;
for (int i = 0; i < s.length(); i++)
{
if (s[i] >= '0' && s[i] <= '9')
{
if (s[i + 1] != '.') //如果数字下一位不为'.',就存放这个数
{
num++; //计算位数
temp[num] = s[i] - '0';
}
else
{
top++; //如果下一位为'.'，就开始整合前面的多位数
num++; //这是存放当前数字
temp[num] = s[i] - '0';
int j = 0;
while (num)
{
linshi[h] += temp[num] * pow(10, j); //临时数组存储多位数
j++;
num--;
}
a[top] = linshi[h]; //赋值
h++; //这轮过完就到下一个临时数组，类似于初始化
}
}
else if (s[i] == '.') //啥事都没有
{
}
else if (s[i] == '+')
{
value = a[top - 1] + a[top]; //数值为前两个数的和，注意顺序
top -= 1; //两个数变一个数，栈顶-1
a[top] = value; //当前栈顶更新为计算出的value
} //下同
else if (s[i] == '-')
{
value = a[top - 1] - a[top];
top -= 1;
a[top] = value;
}
else if (s[i] == '*')
{
value = a[top - 1] * a[top];
top -= 1;
a[top] = value;
}
else if (s[i] == '/')
{
value = a[top - 1] / a[top];
top -= 1;
a[top] = value;
}
else if (s[i] == '@')
{
cout << value;
}
}
}
队列安排
题目描述
一个学校里老师要将班上 N N N 个同学排成一列，同学被编号为 1 ∼ N 1\sim N 1∼N，他采取如下的方法：
- 先将 1 1 1 号同学安排进队列，这时队列中只有他一个人；
- 2 − N 2-N 2−N 号同学依次入列，编号为 i i i 的同学入列方式为：老师指定编号为 i i i 的同学站在编号为 1 ∼ ( i − 1 ) 1\sim(i-1) 1∼(i−1) 中某位同学（即之前已经入列的同学）的左边或右边；
- 从队列中去掉 M ( M < N ) M(M<N) M(M<N) 个同学，其他同学位置顺序不变。
在所有同学按照上述方法队列排列完毕后，老师想知道从左到右所有同学的编号。
输入格式
第 1 1 1 行为一个正整数 N N N，表示了有 N N N 个同学。
第 2 ∼ N 2\sim N 2∼N行，第 i i i 行包含两个整数 k , p k,p k,p，其中 k k k 为小于 i i i 的正整数， p p p 为 0 0 0 或者 1 1 1。若 p p p 为$ 0$，则表示将 i i i 号同学插入到 k k k 号同学的左边， p p p 为 1 1 1 则表示插入到右边。
第 N + 1 N+1 N+1 行为一个正整数 M M M，表示去掉的同学数目。
接下来 M M M 行，每行一个正整数 x x x，表示将 x x x 号同学从队列中移去，如果 x x x 号同学已经不在队列中则忽略这一条指令。
输出格式
1 1 1 行，包含最多 N N N 个空格隔开的正整数，表示了队列从左到右所有同学的编号，行末换行且无空格。
样例 #1
样例输入 #1
4
1 0
2 1
1 0
2
3
3
样例输出 #1
2 4 1
提示
样例解释：
将同学 2 2 2 插入至同学 1 1 1 左边，此时队列为：
2 1
将同学 3 3 3 插入至同学 2 2 2 右边，此时队列为：
2 3 1
将同学 4 4 4 插入至同学 1 1 1 左边，此时队列为：
2 3 4 1
将同学 3 3 3 从队列中移出，此时队列为：
2 4 1
同学 3 3 3 已经不在队列中，忽略最后一条指令
最终队列：
2 4 1
数据范围
对于 20 % 20\% 20% 的数据，有 1 ≤ N ≤ 10 1\leq N\leq 10 1≤N≤10；
对于 40 % 40\% 40% 的数据，有 1 ≤ N ≤ 1000 1\leq N\leq 1000 1≤N≤1000；
对于 100 % 100\% 100% 的数据，有 1 ≤ N , M ≤ 100000 1\leq N,M\leq100000 1≤N,M≤100000。
典型的链表模板题
AC代码如下
#include <iostream>
using namespace std;
int N, k, p, M;
struct Queue_arrangement
{
int l, r;
int d;
} t[100005] = {0};
void add(int i, int k, int p)
{
if (p == 1) //将i号同学插入到k号同学的右边
{
t[i].r = t[k].r;
t[i].l = k;
t[k].r = i;
t[t[i].r].l = i;
}
else //左边
{
t[i].l = t[k].l;
t[i].r = k;
t[k].l = i;
t[t[i].l].r = i;
}
}
void del(int x) //删除x号同学
{
if (t[x].l == 0 && t[x].r == 0)
return; //如果已经删除，则忽略
t[t[x].l].r = t[x].r;
t[t[x].r].l = t[x].l;
t[x].l = t[x].r = 0;
}
int main()
{
t[0].r = 0, t[0].l = 0; //假定一个编号为0的同学，从他的右边1号开始
add(0, 1, 1); //最后回到0同学表示结束（t[last].r==0）
cin >> N;
for (int i = 2; i <= N; i++)
{
cin >> k >> p;
add(i, k, p); //将i号同学插入k的旁边
}
cin >> M;
for (int i = 1; i <= M; i++)
{
int x;
cin >> x;
del(x); //删除x号同学
}
for (int i = t[0].r; i; i = t[i].r) //从0号的右边也就是1号开始遍历
{
if (t[i].l != 0 || t[i].r != 0)
{
if (i == t[0].r) //行末不能有空格，因此第一个单独输出
cout << i;
else
cout << " " << i;
}
}
cout << endl;
}
vector
定义一组长度不定的数组
// variable length array
// Linus: VLA慢、产生太多代码、和不安全（脆弱）
int n;
cin >> n;
int a[n];
// 我见过有同学数组是这样定义的，这里强调一下，不要这么写
// 定义数组的时候，数组长度要用常量，像下面这样
const int maxn = 2e5 + 5;
// 写数字的时候建议写成2e5这样的形式，这样0的个数不会错
int a[maxn];
// 算法竞赛里基本不会使用指针，所以这种写法不多赘述，之后也不会讲
int * a = (int *)malloc(n * sizeof(int)); // 自己分配内存，用完后自己释放
free(a); // 用完之后自己释放
vector <int> a; // 算法竞赛里更常用的写法
定义
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; // > > 分开写，有的编译器不分开会当成右移符合>>
size()
该函数会返回一个size_t类型的值，表示vector内元素的个数（数组的长度）
int len = v.size();
// v.size()是 size_t 类型，注意这是一个无符号整数类型，在64位系统中为long long unsigned int，非64位系统中为long unsigned int
// 所以当v.size() == 0 的时候，v.size() - 1是一个很大的正数，而不是负一。切记切记。
resize()
// 如果原本内存里不够5个元素，那么调用v[4]就会出现段错误
v.resize(5);
// 给vector重新分配内存，之后v内有5个元素,调用v[4]就不会有问题了
// 如果原本vector里元素个数已经多于5个了，那么调用resize(5)以后，vector会删除之后多于的元素
push_back()
vector <int> v1;
vector <node> v2;
node s;
v1.push_back(5);
v2.push_back(s);
// 在vector末尾添加元素，自动增加vector的长度
遍历
// vector 可以像数组一样访问。
vector <int> v;
// 从小到大遍历
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << endl;
}
// c++11支持的语法，功能和上面一样
for (auto x: v) {
cout << x << endl;
}
链表
链表是一种 物理存储结构上非连续 、非顺序的存储结构，数据元素的 逻辑顺序 是通过链表中的 指针链接 次序实现的 。
在现实生活中，如果我们想要按照之前排好的顺序进行排队的话。队伍中的每一个人并不需要知道整个队列的顺序，我们只需要知道排在我们后面（或者前面）的人是谁，那么，我们就可以通过排在队伍最前端的人找到队列里面所有的人。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LqVZJkv2-1668051402310)(img/链表中的节点.png)]
类似于按顺序排队，链表中的每个节点在存储本身的相关信息的时候，还要再存储一个前驱或者后继。
用数组模拟的话，代码是这样的：
struct student {
string name; // 节点本身的信息，比如说姓名
int next; // 后继，排在我后面的人的下标
};
student a[100]; // 用数组来存储学生的信息
//（一般来说都是用指针实现的，但是算法竞赛不大用指针）
增加与删除链表中的元素
链表可以以O(1)的效率快速地增加和删除元素。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V76TEhYn-1668051402310)(img/插入节点1.png)]
如图所示的链表表示的队列。现在希望在原来的队列中加入一个标号为10的学生，这个学生排在标号为1的学生的后面。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vplzxed1-1668051402310)(img/插入节点2.png)]
那我们只需要先告诉10号：“1后面的人是6号，你进入队伍以后，后面的人就是6号。”
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MpbFoB4N-1668051402311)(img/插入节点3.png)]
然后再告诉1号：“现在你后面的人是10号。”
这样就完成了一个单向链表的插入。
这个过程用代码来表示，就是这样的。
a[10].next = a[1].next; // 10进入队列，原本1后面的人现在变成10后面的人
a[1].next = 10; // 1后面的人变成10
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DcKwnb6N-1668051402311)(img/插入节点3.png)]
如果想要把10号同学踢出队伍，我们需要找到他前面的1号同学。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bO7C4PiJ-1668051402311)(img/插入节点2.png)]
然后告诉1号：“10号走了，他后面的人现在变成你后面的人了。”
然后10号就事实上被踢出队伍了。这个时候我们就可以把10号的信息清空。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8c0uSJu-1668051402312)(img/链表示意图.png)]
这样就实现了删除。代码如下：
a[1].next = a[10].next;
a[10].next = 0;
双向链表
刚刚介绍的是单向链表，单向链表中每个节点只存了他的后继或者前驱，在遍历链表的时候，只能从一个方向遍历。
而双向链表存了前驱和后继，这使得他两个方向都可以遍历。
这里我把这个人的洛谷P1160题解稍加改动,拿来供大家参考。
原文地址：https://www.luogu.com.cn/blog/BTLi/solution-p1160
我们可以把每相邻的的两个同学想象成他们牵着手（如图）
既然如此，我们就只需要改动左右手指向的同学就可以了 定义一个结构体
struct T{
int l,r; // 每个同学的“左右手”就是链表节点的前驱和后继
}t[mx]={0};
现在我们就手动模拟一下加入同学（以右边为例） 将编号为 J J J 的同学加入编号为 i i i 的同学右边
第一步 J J J 的右手牵 I I I 右手牵的同学
t[j].r=t[i].r;
**第二步 J J J 的左手牵 I I I
t[j].l=i;
**第三步 I I I 的右手牵 J J J **
t[i].r=j;
**第四步 J J J 右手牵的同学的左手牵 J J J **
注意：此时 i i i 的右手已经不牵原来那个同学了
t[t[j].r].l=j;
此时J就加入链当中了
左边同理
加入函数如下
void add(int i,int k,int f) //新增同学
{
if(f==1) //将 k 号同学插入到 i 号同学的右边
{
t[k].r=t[i].r;
t[k].l=i;
t[i].r=k;
t[t[k].r].l=k;
}
else //将 k 号同学插入到 i 号同学的左边
{
t[k].r=i;
t[k].l=t[i].l;
t[i].l=k;
t[t[k].l].r=k;
}
}
接下来是移除
我们虽然也可以用上面方法来删除
不过我用的是另一种方法（主要是懒）
我们可以给每个同学一个标记，标记了的将不会输出
struct T{
int l,r; //每个同学的“左右手”
int d; //表示同学是否输出
}t[mx]={0};
结构体
while(m--)
{
cin>>x; //要删去的同学
t[x].d=1; //将该同学标记为不输出
}
标记
ps:其实我更建议写一个del函数，真正从链表里删除。像这样：
void del(int x) { // 删除序号为x的同学
if (t[x].l == 0 && t[x].r == 0) return; //已经被删除就忽略
t[t[x].l].r = t[x].r; // 对于x左边的同学而言，他的右侧换成t[x].r了
t[t[x].r].l = t[x].l; // 同理
t[x].l = t[x].r = 0; // 清空x的信息，表明x已经出列
}
接下来是细节问题
链的初始化
如果我们将1同学先输入进去
t[1].l=1,t[1].r=1;
因为没有其他同学只能自己牵自己（紧紧抱住弱小的自己）
但如果这样，到输出时就有一个问题（以样例为例）找不到开头！所有人最终形成了一个环。
这时我们就要在初始化时动些手脚，在一开始的时候给队伍中加入一个不会被剔除的编号为0的同学，我们遍历链表的时候，从他开始，再次遍历到他的时候就结束遍历。
t[0].r=0,t[0].l=0;
add(0,1,1);
输出代码
for (int i=t[0].r; i; i=t[i].r) // i就是链表上元素的地址(下标)
{
if (t[i].d==0) //输出未标记的
cout<<i<<" ";
}
栈
介绍一下几个概念
栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。
栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。
可以用一个数组来模拟栈
int sta[1005]; // 用来存储栈内数据的数组
int top; // 栈顶元素的下标
向栈内添加元素x
++top;
sta[top] = x;
删除栈顶元素
sta[top] = 0; // 其实可以省略，因为添加元素的时候会被覆盖
--top;
以判断括号是否匹配为例
我们读入一串括号字符串
()[()]{[]()[}
之后遍历字符串。
- 遇到左括号，将左括号存入栈中
- 遇到右括号，栈顶的元素就是理论上应该与这个右括号匹配的左括号
- 如果匹配，说明目前为止一切正常，删除栈顶元素
- 如果不匹配，说明这串括号不匹配
代码可以这样写：
char sta[1005], top; // 数据范围是我乱写的
bool check(string s) {
top = 0;
int len = s.length();
for (int i = 0; i < len; ++i) {
if (s[i] == '(' || s[i] == '[' || s[i] == '{') {
++top;
sta[top] = s[i];
} else {
char pr;
if (s[i] == ')') pr = '(';
if (s[i] == ']') pr = '[';
if (s[i] == '}') pr = '{';
if (top == 0 || sta[top] != pr) return 0; // 不匹配
else --top; // 匹配就删除栈顶元素
}
}
if (top > 0) return 0;
return 1;
}
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
