A - 咕咕东的目录管理器（Week9.1作业)

题目

咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能帮助东东！

初始时，咕咕东的硬盘是空的，命令行的当前目录为根目录 root。

目录管理器可以理解为要维护一棵有根树结构，每个目录的儿子必须保持字典序。

现在咕咕东可以在命令行下执行以下表格中描述的命令：

命令	类型	实现	说明
MKDIR s	操作	在当前目录下创建一个子目录 s，s 是一个字符串	创建成功输出 “OK”；若当前目录下已有该子目录则输出 “ERR”
RM s	操作	在当前目录下删除子目录 s，s 是一个字符串	删除成功输出 “OK”；若当前目录下该子目录不存在则输出 “ERR”
CD s	操作	进入一个子目录 s，s 是一个字符串（执行后，当前目录可能会改变）	进入成功输出 “OK”；若当前目录下该子目录不存在则输出 “ERR”;特殊地，若 s 等于 “…” 则表示返回上级目录，同理，返回成功输出 “OK”，返回失败（当前目录已是根目录没有上级目录）则输出 “ERR”
SZ	询问	输出当前目录的大小	也即输出 1+当前目录的子目录数
LS	询问	输出多行表示当前目录的 “直接子目录” 名	若没有子目录，则输出 “EMPTY”；若子目录数属于 [1,10] 则全部输出；若子目录数大于 10，则输出前 5 个，再输出一行 “…”，输出后 5 个。
TREE	询问	输出多行表示以当前目录为根的子树的前序遍历结果	若没有后代目录，则输出 “EMPTY”；若后代目录数+1（当前目录）属于 [1,10] 则全部输出；若后代目录数+1（当前目录）大于 10，则输出前 5 个，再输出一行 “…”，输出后 5 个。若目录结构如上图，当前目录为 “root” 执行结果如下:
UNDO	特殊	撤销操作	撤销最近一个 “成功执行” 的操作（即MKDIR或RM或CD）的影响，撤销成功输出 “OK” 失败或者没有操作用于撤销则输出 “ERR”

输入

输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；

每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；

每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。

输出

每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
时空限制

Time limit 6000 ms

Memory limit 1048576 kB

样例输入

1
22
MKDIR dira
CD dirb
CD dira
MKDIR a
MKDIR b
MKDIR c
CD …
MKDIR dirb
CD dirb
MKDIR x
CD …
MKDIR dirc
CD dirc
MKDIR y
CD …
SZ
LS
TREE
RM dira
TREE
UNDO
TREE

样例输出

OK
ERR
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
9
dira
dirb
dirc
root
dira
a
b
c
dirb
x
dirc
y
OK
root
dirb
x
dirc
y
OK
root
dira
a
b
c
dirb
x
dirc
y

题目思路

这是一道比较复杂的模拟题，模拟操作系统目录管理器的七个功能；
MKDIR：创建子目录，now指针不变，要记录；
RM：删除子目录，now指针不变，需要记录；
CD：进入指定目录，now指针改变，需要记录；
SZ：输出当前目录大小，now不变，不需要记录；
LS：输出当前目录的子目录，now不变，不需要记录；
TREE：输出以当前目录为根的子树的前序遍历结果，now不变，不需要记录；
UNDO：撤销操作，now可能改变，不需要记录。

分析以上七个操作，需要now指针指向当前目录所在位置；
由于撤销操作，我们需要记录MKDIR、RM、CD三个操作，我们选择用vector来记录

vector<pair<string,pair<int,int> > > record;
//操作名字、操作时的now指针、操作对象

对于目录我们可以看做是一棵多节点树，那么我们可以用链式前向星来存储，对每一个节点进行封装，
MKDIR时赋予节点一个名字以及一个独一无二的索引、父节点和子节点，
RM和CD对子节点和父节点进行操作，
SZ需要以节点为根的树的节点数量，
LS对节点的子节点操作，
TREE需要以当前目录为根的子树的前序遍历结果，
UNDO对record操作。
对于SZ操作，我们维护一个size值，而对于TREE操作，我们可以使用“懒更新”的方法，利用tag记录当前节点的子树前序遍历结果是否已经更新并存储在对应的vector中，如果是更新好的直接输出，否则更新再输出。
综上，我们定义节点的结构体是：

struct Dict
{
	string name;
	int sz,fa;
	map<string,int> mp;
	vector<string> pre,bck;
	bool tag;
	void init(string t,int p)//初始化函数
	{
		name=t;
		fa=p;
		sz=1;
		mp.clear();
		pre.clear();bck.clear();
		tag=0;
	}
}dict[maxn];

另外我们可以将当前操作也封装起来，包含操作的名字、操作对应的标号等信息

struct command{
	string name,st;
	int sign;
	void init(string t){
		name=t;
		for(int i=0;i<7;i++)
		{
			if(t==cmd_tot[i])
			{
				sign=i;
				if(sign<3) cin>>st;
				break;
			}
		}
	}
}cmd;

然后一个一个地实现功能；

代码总结

1、使用vector和auto可以在一定程度上简化代码（auto的具体用法在C++学习笔记一）；
2、在定义变量名字的时候，尤其是像这道需要很多变量名的题，变量名一定要清晰而且简便。记录数组dcit原名是catalog，到后面代码越来越长，而且容易打错；还有一些地方命名不清晰，tmp和temp容易搞混；
3、使用“懒更新”降低时间复杂度；
4、switch（）case n:break使用，可以简化代码
5、在结构体中定义初始化函数；
6、结构体的封装可以使代码更加清晰简洁。

代码实现

#include<bits/stdc++.h>
using namespace std;
int cnt,T,n,now;
const int maxn=1e5+5;
const string cmd_tot[]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
vector<pair<string,pair<int,int> > > record;
struct command{
	string name,st;
	int sign;
	void init(string t){
		name=t;
		for(int i=0;i<7;i++)
		{
			if(t==cmd_tot[i])
			{
				sign=i;
				if(sign<3) cin>>st;
				break;
			}
		}
	}
}cmd;//记录当前操作
struct Dict
{
	string name;
	int sz,fa;
	map<string,int> mp;
	vector<string> pre,bck;
	bool tag;
	void init(string t,int p)
	{
		name=t;
		fa=p;
		sz=1;
		mp.clear();
		pre.clear();bck.clear();
		tag=0;
	}
}dict[maxn];//目录 
void add(string s,int p)
{
	cnt++;
	dict[cnt].init(s,p);
	dict[p].mp[s]=cnt;
}
void update(int id,int num)
{
	while(id!=-1)
	{
		dict[id].sz+=num;
		dict[id].tag=0;
		id=dict[id].fa;
	}
}
void mkdir()
{
	if(dict[now].mp.count(cmd.st)){//创建目录已存在 
		cout<<"ERR"<<endl;
		return; 
	}
	add(cmd.st,now);
	update(now,1);//更新size
	record.push_back(make_pair("MKDIR",make_pair(now,cnt)));
	cout<<"OK"<<endl; 
}
void rm()
{
	if(!dict[now].mp.count(cmd.st)){//目录中没有
		cout<<"ERR"<<endl; 
		return;
	}
	int tmp=dict[now].mp[cmd.st];
	update(now,(-1)*dict[tmp].sz);
	dict[now].mp.erase(dict[tmp].name);
	record.push_back(make_pair("RM",make_pair(now,tmp)));
	cout<<"OK"<<endl;
}
void cd()
{
	if(cmd.st==".."){
		if(dict[now].fa==-1)
		{
			cout<<"ERR"<<endl;
			return;
		}
		record.push_back(make_pair("CD",make_pair(now,dict[now].fa)));
		now = dict[now].fa;	
		cout<<"OK"<<endl;
		return;
	}
	if(!dict[now].mp.count(cmd.st)){
		cout<<"ERR"<<endl;
		return;
	}
	int tmp=dict[now].mp[cmd.st];
	record.push_back(make_pair("CD",make_pair(now,tmp)));
	now=tmp; 
	cout<<"OK"<<endl;
}
void sz()
{
	cout<<dict[now].sz<<endl;
}
void ls()
{
	int l=dict[now].mp.size();
	if(l==0){
		cout<<"EMPTY"<<endl;
		return;
	}
	if(l>=1 && l<=10)
	{
		auto tmp=dict[now].mp;
		for(auto i=tmp.begin();i!=tmp.end();i++){
			cout<<i->first<<endl;	
		}
	}
	else{
		auto tmp=dict[now].mp.begin();
		for(int i=0;i<5;i++){
			cout<<tmp->first<<endl;	
			tmp++;
		}
		cout<<"..."<<endl;
		auto curr=dict[now].mp.end();
		for(int i=0;i<5;i++) curr--;
		for(int i=0;i<5;i++){
			cout<<curr->first<<endl;
			curr++;
		}
	}
}
void bckupdate(int p);
void preupdate(int p);
void renewal(int p)
{
	dict[p].pre.clear();
	dict[p].bck.clear();
	preupdate(p);
	if(dict[p].sz>10) bckupdate(p);
	else dict[p].bck=dict[p].pre;
	dict[p].tag=1;
}
void preupdate(int p)
{ 
	dict[p].pre.push_back(dict[p].name);
	if(dict[p].sz==1) return;
	else if(dict[p].sz>1&&dict[p].sz<=10){
		for(auto i:dict[p].mp)
		{
			if(!dict[i.second].tag) renewal(i.second);
			dict[p].pre.insert(dict[p].pre.end(),dict[i.second].pre.begin(),dict[i.second].pre.end());
		}
		return;
	}
	int tempcnt=0;
	for(auto i:dict[p].mp)
	{
		if(!dict[i.second].tag) renewal(i.second);
		for(auto j:dict[i.second].pre){
			dict[p].pre.push_back(j);
			tempcnt++;
			if(tempcnt>5) break;
		}
		if(tempcnt>5) break;
	}	
}
void bckupdate(int p)
{
	int tempcnt=0;//计数
	auto curr=dict[p].mp.end();
	while(tempcnt<5)
	{
		curr--;
		if(!dict[curr->second].tag) renewal(curr->second); 
		for(int i=dict[curr->second].bck.size()-1;i>=0;--i)
		{
			dict[p].bck.push_back(dict[curr->second].bck[i]);
			tempcnt++; 
			if(tempcnt>=5) break;
		}
		if(curr==dict[p].mp.begin()) break;
	} 
	reverse(dict[p].bck.begin(),dict[p].bck.end());
}
void tree()
{
	if(!dict[now].tag) renewal(now);
	if(dict[now].sz==1) cout<<"EMPTY"<<endl;
	else if(dict[now].sz>1 && dict[now].sz<=10){
		for(int i=0;i<dict[now].pre.size();i++)
			cout<<dict[now].pre[i]<<endl;
	}
	else
	{
		for(int i=0;i<5;i++) cout<<dict[now].pre[i]<<endl;
		cout<<"..."<<endl;
		for(int i=5;i>=1;i--) cout<<dict[now].bck[dict[now].bck.size()-i]<<endl;
	}	
}
void undo()
{
	if(record.size()==0)
	{
		cout<<"ERR"<<endl;
		return;
	}
	auto e = record[record.size()-1];
	record.pop_back();
	int tmp=now;//记录下当前的目录 
	if(e.first=="MKDIR"){
		now=e.second.first;
		cmd.name="RM";
		cmd.st=dict[e.second.second].name;
		int u=dict[now].mp[cmd.st];
		update(now,(-1)*dict[u].sz);
		dict[now].mp.erase(dict[u].name);
		now=tmp;
	}
	else if(e.first=="RM"){
		now=e.second.first;
		int u=e.second.second;
		update(now,dict[u].sz);
		dict[now].mp[dict[u].name]=u;
		now=tmp;
	}
	else{
		now=e.second.first;
	}
	cout<<"OK"<<endl;
}
void init()
{
	cnt=0;now=0;
	record.clear();
	dict[0].init("root",-1);
}
int main()
{
	//freopen("a.txt","r",stdin);
	cin>>T; 
	while(T--)
	{
		cin>>n;
		init();
		for(int i=0;i<n;i++)
		{
			string str;
			cin>>str;
			cmd.init(str);
			switch(cmd.sign)
			{
				case 0: mkdir(); break;
				case 1: rm(); break;
				case 2: cd(); break;
				case 3: sz(); break;
				case 4: ls(); break;
				case 5: tree(); break;	
				case 6: undo(); break;
			}
		}
		cout<<endl;
	}
	return 0;
}