Week3 线性表

线性表

【深基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

样例输入 #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 数据。

代码

#include<iostream>
#include<map>
using namespace std;

map<int, int> str[10010];  //map数组存放数据

int main() {

	int n, q;
	cin >> n >> q;
	for (int u = 0; u < q; ++u) {
		int operation, i, j;
		cin >> operation >> i >> j;
		if (operation == 1) {  //存数据
			int k;
			cin >> k;
			str[i].insert(pair<int,int>(j,k));
		}
		else {
			cout << str[i].at(j) << endl;
		}
	}
	
	return 0;
}

注意点

• 存储数据的时候不可以直接暴力二维数组 a[100000][100000], 会超出内存限制，但可以使用 map<int, int> str[100000], 一个表数组来存储数据

括号序列

题目描述

定义如下规则：

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

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

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

而以下几个则不是：

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

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

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

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

输入格式

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

输出格式

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

样例 #1

样例输入 #1

([()

样例输出 #1

()[]()

样例 #2

样例输入 #2

([)

样例输出 #2

()[]()

提示

数据规模与约定

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

代码

#include<iostream>
#include<stack>
using namespace std;

int main() {
	pair<char, int> c[110];
	stack<pair<char,int>> p;
	bool match[110];  //看括号是否有匹配的
	for (int i = 0; i < 110; ++i)
		match[i] = false;
	string s, ans;
	cin >> s;
	for (int i = 0; i < s.length(); ++i) {
		if (s[i] == '(' || s[i] == '[') {  //左括号
			p.push(pair<char, int>(s[i], i));
		}
		else {  //右括号
			if (!p.empty()) {
				char c = p.top().first;
				if (c == '(' && s[i] == ')' || c == '[' && s[i] == ']') {
					match[p.top().second] = true;
					match[i] = true;
					p.pop();
				}
			}
		}
	}
	for (int i = 0; i < s.length(); ++i) {
		if (match[i])
			ans += s[i];
		else {
			switch (s[i]) 
			{
			case'(': ans = ans + s[i] + ')';
				break;
			case')':ans = ans + '('+ s[i] ;
				break;
			case'[': ans = ans + s[i] + ']';
				break;
			case']':ans = ans + '[' + s[i];
				break;
			
			}
		}
	}
	cout << ans;


}

注意点

• 创建一个 match bool数组，存储当前下标的括号是否有匹配，方便后续判断以及补全
• 创建一个 p 栈， 里面放的元素为二元组 Pair<int, char>，int部分对应下标，char部分对应当前括号
• 若当前读的符号为 ‘(’ 或者 ‘[’，元素入栈；若当前的元素为 ‘)’ 或者 ‘]’，匹配的话就将栈顶元素弹出，将当前括号的下标和栈顶元素的下标在 match 数组中找到，设为 true。不匹配则将两个都设为false
• 最后遍历 match 数组，将不匹配的元素加上相匹配的符号

后缀表达式

题目描述

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

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

输入格式

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

输出格式

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

样例 #1

样例输入 #1

3.5.2.-*7.+@

样例输出 #1

16

提示

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

代码

#include<iostream>
#include<stack>
using namespace std;

int operate(int a, int b, char op) {  //运算
	switch (op) {
	case'-': return a - b;
	case'+': return a + b;
	case'*': return a * b;
	case'/': return a / b;
	}
}

int main() {
	stack<int> num;
	stack<char> oper;

	char c;
	int temp = 0;
	while ((c = getchar()) != '@') {
		if (c == '.') {  //终止符号，将数字放入数字栈
			if (temp) {
				num.push(temp);
				temp = 0;
			}
			
		}
		else if ('0' <= c && c <= '9') {  
			temp = temp * 10 + (c - '0');
		}
		else {  //符号
			if (temp != 0) {  //前面有数字，先将数字放入数字栈
				num.push(temp);
				temp = 0;
			}
			int b = num.top();
			num.pop();
			int a = num.top();
			num.pop();
			num.push(operate(a, b, c));
		}
	}
	cout << num.top();
	




	return 0;
}

注意点

• 设置一个数字栈，用来放置数字
• 题目中并未规定数字一定是只有一位的，所以在读数字的时候要使用 temp = temp * 10 + (c - ‘0’) 来获得真正的数字，若一个一个读会使得数字 30 读成 3 和 0
• '.'表示当前操作数结束，如果当前有数字就将数字推入栈中
• 如果当前读入的字符为操作符号，先把数字存入数字栈（如果有的话），弹出数字栈中的前面两个数字，然后进行运算，注意两个数字的运算顺序

队列安排

题目描述

一个学校里老师要将班上 $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

样例输入 #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$。

代码

#include<iostream>
using namespace std;

typedef struct node {
	bool deque;  //是否出队了
	int next;
	int pre;
}node;

node a[100010];  //静态链表

int main() {

	a[0].pre = 1;
	a[0].deque = false;
	a[0].next = 1;

	a[1].pre = 0;
	a[1].deque = false;
	a[1].next = -1;

	int p;
	cin >> p;
	for (int i = 2; i <= p; ++i) {
		int n, side;
		cin >> n >> side;

		a[i].deque = false;
		if (side == 0) {  //放在左边
			a[a[n].pre].next = i;
			a[i].pre = a[n].pre;
			a[n].pre =i;
			a[i].next = n;
		}
		else {  //放在右边
			a[a[n].next].pre = i;
			a[i].next = a[n].next;
			a[n].next = i;
			a[i].pre = n;
		}
	}
	/*cout << endl;
	for (int i = 0; i <= p; ++i) {
		cout << "a[i].seq = " << a[i].seq << " a[i].next = " << a[i].next
			<< " a[i].pre = " << a[i].pre;
		cout << endl;
	}*/
	
	int op;
	cin >> op;
	for (int i = 0; i < op; ++i) {
		int remove;
		cin >> remove;
		if (!a[remove].deque) {
			a[remove].deque = true;
			int preSeq = a[remove].pre;
			int nextSeq = a[remove].next;
			a[preSeq].next = nextSeq;
			a[nextSeq].pre = preSeq;
		}
		
	}

	
	int cur = a[0].next;
	while (cur != -1 && !a[cur].deque) {
		cout << cur << " ";
		cur = a[cur].next;
	}

	return 0;
}

注意点

• 如果使用数组的来存储会使得删除插入非常麻烦，而使用链表访问过慢。想到静态双向链表，访问前驱容易，访问后继也容易,可以随机访问且插入删除相对容易。
• 数组元素为

typedef struct node {
	bool deque;  //是否出队了
	int next;  //下一个
	int pre;  //上一个
}node;