【洛谷B3631】单向链表 解题报告

B3631 单向链表 传送门

题目描述

实现一个数据结构，维护一张表（最初只有一个元素 $1$）。需要支持下面的操作，其中 $x$ 和 $y$ 都是 $1$ 到 $10^6$ 范围内的正整数，且保证任何时间表中所有数字均不相同，操作数量不多于 $10^5$：

• 1 x y ：将元素 $y$ 插入到 $x$ 后面；
• 2 x ：询问 $x$ 后面的元素是什么。如果 $x$ 是最后一个元素，则输出 $0$；
• 3 x：从表中删除元素 $x$ 后面的那个元素，不改变其他元素的先后顺序。

输入格式

第一行一个整数 $q$ 表示操作次数。

接下来 $q$ 行，每行表示一次操作，操作具体间题目描述。

输出格式

对于每个操作 2，输出一个数字，用换行隔开。

样例 #1

样例输入 #1

6
1 1 99
1 99 50
1 99 75
2 99
3 75
2 1

样例输出 #1

75
99

---

最近在学408数据结构，刚学完单链表，于是上洛谷找题找到了这个。
读一下题。
嗯，很标准的单链表板子题，非常适合用来练手。
操作1，后插操作。
操作2，按值查找。
操作3，按值删除。
直接走标准流程打了一波，然后TLE了两个点……
以下是80pts的代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;

typedef struct LNode {
	int data;
	LNode* next;
}LNode, * LinkList;

void InitList(LinkList& L) {//初始化
	L = (LinkList)malloc(sizeof(LNode));
	if (L == NULL)return;
	LNode* s;
	s = (LNode*)malloc(sizeof(LNode));
	s->data = 1;
	L->next = s;
	s->next = NULL;
	return;
}

LNode* GetElem(LinkList& L, int e) {//按值查找（基本操作），时间复杂度O(n)
	LNode* r = L;
	for (; r != NULL && r->data != e; r = r->next);
	if (r == NULL)return NULL;
	else return r;
}

void List_TailInsert(LinkList& L, int x, int y) {//后插操作
	LNode* s, * r = GetElem(L, x);
	if (r == NULL)return;
	s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)return;
	s->data = y;
	s->next = r->next;
	r->next = s;
	return;
}

void FindNextElem(LinkList& L, int x) {//按值查找（题目要求）
	LNode* r = GetElem(L, x);
	if (r == NULL || r->next == NULL)printf("0\n");
	else printf("%d\n", r->next->data);
	return;
}

void DeleteNextElem(LinkList& L, int x) {//按值删除
	LNode* s, * r = GetElem(L, x);
	if (r == NULL || r->next == NULL)return;
	s = r->next;
	r->next = s->next;
	free(s);
	return;
}

int main() {
	int p, q, x, y;
	LinkList L;
	InitList(L);
	scanf("%d", &p);
	while (p--) {
		scanf("%d", &q);
		if (q == 1) {
			scanf("%d %d", &x, &y);
			List_TailInsert(L, x, y);
		}else if (q == 2) {
			scanf("%d", &x);
			FindNextElem(L, x);
		}else if (q == 3) {
			scanf("%d", &x);
			DeleteNextElem(L, x);
		}
	}
	return 0;
}

之后问了一下计算机学院的哥们，他说链表的各种基本操作都有优化算法……
鉴于我是初学者，就暂时没有涉及，循序渐进为好。
所以，按标准的单链表写法做这题肯定是A不掉了，因为有多达$10^5$个操作数。
再读一遍题，我注意到这么一段文字：

且保证任何时间表中所有数字均不相同

哈……哈希？

好好好，这么玩是吧，这下不得不祭出野鸡写法了。（大嘘
于是靠着吃五年前的OI老本，把所有操作都优化到O(1)的时间复杂度，然后直接A了。
以下是100pts的代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
const int MAXN = 1e6+7;

struct List{
	int data=0;
	int next=0;//因为本题没有重复的数据元素，所以直接用next记录下一个结点
//并且因为本题中所有数据元素都介于1到10^6之间，所以初值直接置零
}L[MAXN];//直接用数组存放各数据元素之间的联系

inline int qread(){//快读
	int x=0,w=1;
	char ch=0;
	while(ch<'0'||ch>'9'){
		if(ch=='-')w=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=x*10+(ch-'0');
		ch=getchar();
	}
	return x*w;
}

inline void Insert(int x,int y){//后插操作
	L[y].next=L[x].next;//将x的后继赋给y的后继
	L[x].next=y;//将x的后继赋为y
	L[y].data=y;//写入数据
	return;
}

inline void Find(int x){//寻值操作
	if(L[x].next==0)printf("0\n");//如果x没有后继输出0
	else{
		int y=L[x].next;
		printf("%d\n",L[y].data);//如果x有后继就输出后继的数据值
	}
	return;
}

inline void Del(int x){//删除操作
	int y=L[x].next;//临时变量y表示x的后继元素
	L[y].data=0;//数据置零（都不用free了）
	L[x].next=L[y].next;//直接让x的后继继承y的后继
	L[y].next=0;//释放“指针”
	return;
}

int main(){
	int p,q,x,y;
	p=qread();
	L[1].data=1;//初始化
	while(p--){
		q=qread();
		switch(q){
			case 1:x=qread(),y=qread();Insert(x,y);break;
			case 2:x=qread();Find(x);break;
			case 3:x=qread();Del(x);break;
			default:break;
		}
	}
	return 0;
}

令人感叹，正规写法超时，“野鸡”写法AC，不过也是因为这题是这么出的，所以才能对症下药。
为什么说野鸡，因为不是通解，如果有重复数据就gg了。
不过用来打板子练手还是可以的。
继续加油吧。