线性表练习

AC-MAN

于 2022-11-21 17:17:20 发布

阅读量1k

点赞数

文章标签：算法 c++

本文链接：https://blog.csdn.net/HEYONANA/article/details/127968038

版权

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

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

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

输入格式

第一行 2 个整数 nn 和 qq，寄包柜个数和询问次数。

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

输出格式

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

输入输出样例

输入 #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}upd 2022.7.26：新增加一组 Hack 数据。

这题乍一看肯定会第一时间想到二维数组，但是如果创建一个那么大的数组肯定会超内存不说，也会浪费很多空间。为了能够节省空间，于是我们使用stl库中的map，效果类似二维数组，但是没有输入的部分不会分配内存，很好的解决了超内存问题。ac代码如下

#include<iostream>
#include<map>
using namespace std;
map<int,int>a[100005];
int main()
{
	int n,q,pan,h,l,c;
	cin>>n>>q;
	while(q--)
	{
		cin>>pan;
		if(pan==1)
		{
			cin>>h>>l>>c;
			a[h][l]=c;
		}
		else
		{
			cin>>h>>l;
			cout<<a[h][l]<<endl;
		}
	}
	
	return 0;
}

# 括号序列

## 题目描述

定义如下规则：

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

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

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

而以下几个则不是：

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

现在，给定一个仅由 `(`，`)`，`[`，`]`构成的字符串 $s$，请你按照如下的方式给字符串中每个字符配对：
1. 从左到右扫描整个字符串。
2. 对于当前的字符，如果它是一个右括号，考察它与它左侧离它**最近**的**未匹配**的的左括号。如果该括号与之对应（即小括号匹配小括号，中括号匹配中括号），则将二者配对。如果左侧未匹配的左括号不存在或与之不对应，则其配对失败。

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

## 输入格式

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

## 输出格式

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

## 样例 #1

### 样例输入 #1

```
([()
```

### 样例输出 #1

```
()[]()
```

## 样例 #2

### 样例输入 #2

```
([)
```

### 样例输出 #2

```
()[]()
```

## 提示

### 数据规模与约定

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

这道题我们需要用到栈的思想，我们可以把栈想成一个弹夹，先压入弹夹的子弹后打出，每次只能击发最上面的一发子弹。

这题中，我们需要两个栈，一个压入左括号，一个压入右括号，以此来判断最新的左右括号是否匹配，如匹配，就将两者标记，并弹出栈，最后输出时补全不匹配的括号即可。

ac代码如下

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
	char fu[100000];
	int zuo[100000];
	int pan[100000];
	int x=0;
	memset(pan,0,sizeof(pan));
	int zg=0,bl=0;
	while((fu[bl]=getchar())!='\n')
	{
		if(fu[bl]=='{' || fu[bl]=='(' || fu[bl]=='[')
		{
			zuo[zg]=bl;
			zg++;
		}
		if(fu[bl]=='}' || fu[bl]==')' || fu[bl]==']')
		{
			if((fu[bl]=='}'&&fu[zuo[zg-1]]=='{')|| (fu[bl]==')'&&fu[zuo[zg-1]]=='(') || (fu[bl]==']'&&fu[zuo[zg-1]]=='['))
			{
				pan[bl]=1;
				pan[zuo[zg-1]]=1;
				zg--;
			}
			
		}
		bl++;
	}
	x=0;
	for(;x<bl;x++)
	{
		if(pan[x]==1)
		{
			cout<<fu[x];
			continue;
		}
		else if(fu[x]=='(' || fu[x]==')')
		{
			cout<<"()";
		}
		else if(fu[x]=='[' || fu[x]==']')
		{
			cout<<"[]";
		}
		else if(fu[x]=='{' || fu[x]=='}')
		{
			cout<<"{}";
		}
	}
	
	
	
	return 0;
}

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

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

输入格式

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

输出格式

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

输入输出样例

输入 #1复制

3.5.2.-*7.+@

输出 #1复制

说明/提示

数据保证，1 \leq |s| \leq 501≤∣s∣≤50，答案和计算过程中的每一个值的绝对值不超过 10^9109。

这题同样也是运用了栈的思想，将数字压入栈，计算时弹出，计算后将结果重新压入栈中。但是这题的难点在于如何同时接收数字与运算符号，我的解决方法是一律以字符接收，如果有连续的数字读入各位数字，输入下一个非数字字符时将数字字符们还原成整数存入一个数组中，将这个数组作为栈。ac代码如下

#include<iostream>
#include<map>
using namespace std;
int main()
{
char ch[51];
int shu[50]={0};
int x=0,s=0;
for(;(ch[x]=getchar())!='@';x++)
{
	if(ch[x]>='0' && ch[x]<='9')
	{
		shu[s]+=(ch[x]-'0');
		if(x>0 && ch[x-1]>='0' && ch[x]<='9')
		{
			shu[s]-=(ch[x]-'0');
			shu[s]*=10;
			shu[s]+=(ch[x]-'0');
		}
	}
	else
	{
		if(x>0 && ch[x-1]>='0' && ch[x-1]<='9')
		{
			s++;
		}
		if(ch[x]=='-')
		{
			shu[s-2]-=shu[s-1];
			s--;
			shu[s]=0;
		}
		if(ch[x]=='+')
		{
			shu[s-2]+=shu[s-1];
			s--;
			shu[s]=0;
		}
		if(ch[x]=='*')
		{
			shu[s-2]*=shu[s-1];
			s--;
			shu[s]=0;
		}
		if(ch[x]=='=')
		{
			shu[s-2]=shu[s-1];
			s--;
			shu[s]=0;
		}
		if(ch[x]=='/')
		{
			shu[s-2]/=shu[s-1];
			s--;
			shu[s]=0;
		}
		
	}
}
cout<<shu[0];

	return 0;
}

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

先将 11 号同学安排进队列，这时队列中只有他一个人；
2-N2−N 号同学依次入列，编号为 ii 的同学入列方式为：老师指定编号为 ii 的同学站在编号为 1\sim(i-1)1∼(i−1) 中某位同学（即之前已经入列的同学）的左边或右边；
从队列中去掉 M(M<N)M(M<N) 个同学，其他同学位置顺序不变。

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

输入格式

第 11 行为一个正整数 NN，表示了有 NN 个同学。

第 2\sim N2∼N行，第 ii 行包含两个整数 k,pk,p，其中 kk 为小于 ii 的正整数，pp 为 00 或者 11。若 pp 为00，则表示将 ii 号同学插入到 kk 号同学的左边，pp 为 11 则表示插入到右边。

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

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

输出格式

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

输入输出样例

输入 #1复制

输出 #1复制

2 4 1

说明/提示

样例解释：

将同学 22 插入至同学 11 左边，此时队列为：

2 1

将同学 33 插入至同学 22 右边，此时队列为：

2 3 1

将同学 44 插入至同学 11 左边，此时队列为：

2 3 4 1

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

2 4 1

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

最终队列：

2 4 1

数据范围

对于 20\%20% 的数据，有 1\leq N\leq 101≤N≤10；

对于 40\%40% 的数据，有 1\leq N\leq 10001≤N≤1000；

对于 100\%100% 的数据，有 1\leq N,M\leq1000001≤N,M≤100000。

这道题是最基础的双向链表的模拟，操作分为插入左，插入右，删除节点，完整输出链表。

ac代码如下

#include<iostream>
using namespace std;
struct node
{
	int key, pre, nxt;
	node(int _key=0,int _pre=0,int _nxt=0)
	{key = _key; pre = _pre; nxt = _nxt;}
}s[100005];
int now;
int index[100005]={0};
int tot=0;
void qian(int x,int y)
{
	int now=index[x];
	s[++tot] = node(y,s[now].pre,now);
	s[s[now].pre].nxt=tot;
	s[now].pre=tot;
	index[y]=tot;
}

void hou(int x,int y)
{
	int now=index[x];
	s[++tot]=node(y,now,s[now].nxt);
	s[s[now].nxt].pre=tot;
	s[now].nxt=tot;
	index[y]=tot;
}

void shan(int x)
{
	int now = index[x];
	s[s[now].pre].nxt = s[now].nxt;
	s[s[now].nxt].pre = s[now].pre;
	index[x]=0;
}

int main()
{
	int n=0;
	cin>>n;
	s[0]=node();
	hou(0, 1);
	int k,p;
	for(int i=2;i<=n;i++)
	{
		cin>>k>>p;
		p?hou(k, i):qian(k, i);
	}
	int m=0;
	cin>>m;
	int dl;
	while(m--)
	{
		cin>>dl;
		if(index[dl])
		{
		shan(dl);
		}
	}
	int w=s[0].nxt;
	for	(;w;w=s[w].nxt)
	{
		cout<<s[w].key<<" ";
	}
	cout<<endl;
	return 0;
}