WEEK9 A 咕咕东的目录管理器

题面

咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零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

思路

此题采用面向对象的思想，把对目录的操作设置为类方法。
首先根据路径的特点将路径设置为一个树形结构，因为子节点要保持字典序，所以孩子节点使用map<string, Directory*>容器来保存，同时保存一个指针指向父路径，使用string保存路径名称，并用一个整型保存子目录大小。
对于TREE操作，需要根据子目录的数量进行判断使用不同的遍历操作，因此，这里在每个目录使用一个容器保存TREE操作的输出，并使用一个标志判断该目录是否被更改，若未更改，则遇到TREE操作时可直接输出上次的输出结果，以达到减少时间复杂度的目的。

代码

#include <iostream>
#include <string>
#include <map>
#include <vector>

using namespace std;

string tmps;
const string CMDNAMES[] = { "MKDIR","RM","CD","SZ","LS","TREE","UNDO" };

struct Directory
{
	string name;
	map<string, Directory*>children;
	Directory* parent;
	int subtreeSize;
	vector<string> tenDescendants;
	bool updated;
	Directory(string name, Directory* parent)
	{
		this->name = name;
		this->parent = parent;
		this->subtreeSize = 1;
	}
public:
	void maintain(int delta)
	{
		this->updated = true;
		subtreeSize += delta;
		if (parent != nullptr)
			parent->maintain(delta);
	}
	void sz()
	{
		printf("%d\n",subtreeSize);
	}
	Directory* getChild(string name)
	{
		auto it = children.find(name);
		if (it == children.end())
			return nullptr;
		return it->second;
	}
	Directory* mkdir(string name)
	{
		if (children.find(name) != children.end())
			return nullptr;
		Directory* ch = new Directory(name, this);
		children[name] = ch;
		maintain(1);
		return ch;
	}
	Directory* rm(string name)
	{
		auto it = children.find(name);
		if (it == children.end())
			return nullptr;
		maintain(-1 * it->second->subtreeSize);
		children.erase(it);
		return it->second;
	}
	Directory* cd(string name)
	{
		if (".." == name)
			return this->parent;
		return getChild(name);
	}
	bool addChild(Directory* ch)
	{
		if (children.find(ch->name) != children.end())
			return false;
		children[ch->name] = ch;
		maintain(ch->subtreeSize);
		return true;
	}
	void ls()
	{
		int sz = children.size();
		if (sz == 0)
			printf("EMPTY\n");
		else if (sz <= 10)
			for (auto it=children.begin();it!=children.end();it++)
				cout<<it->first<<endl;
		else
		{
			auto it = children.begin();
			for (int i = 0; i < 5; i++, it++)
				cout<<it->first<<endl;
			printf("...\n");
			it = children.end();
			for (int i = 0; i < 5; i++)
				it--;
			for (int i = 0; i < 5; i++,it++)
				cout<<it->first<<endl;
		}
	}
	void treeFirstSome(int num, vector<string> &bar)
	{
		bar.push_back(name);
		if (--num == 0)
			return;
		int n = children.size();
		auto it = children.begin();
		while (n--)
		{
			int sts = it->second->subtreeSize;
			if (sts >= num)
			{
				it->second->treeFirstSome(num, bar);
				return;
			}
			else
			{
				it->second->treeFirstSome(sts, bar);
				num -= sts;
			}
			it++;
		}
	}
	void treeLastsome(int num, vector<string> &bar)
	{
		int n = children.size();
		auto it = children.end();
		while (n--)
		{
			it--;
			int sts = it->second->subtreeSize;
			if (sts >= num)
			{
				it->second->treeLastsome(num, bar);
				return;
			}
			else
			{
				it->second->treeLastsome(sts, bar);
				num -= sts;
			}
		}
		bar.push_back(name);
	}
	void treeAll(vector<string> &bar)
	{
		bar.push_back(name);
		for (auto it=children.begin();it!=children.end();it++)
			it->second->treeAll(bar);
	}
	void tree()
	{
		if (subtreeSize == 1)
			printf("EMPTY\n");
		else if (subtreeSize <= 10)
		{
			if (updated)
			{
				tenDescendants.clear();
				treeAll(tenDescendants);
				updated = false;
			}
			for (auto it = tenDescendants.begin(); it != tenDescendants.end(); it++)
				cout << *it << endl;
		}
		else
		{
			if (updated)
			{
				tenDescendants.clear();
				treeFirstSome(5, tenDescendants);
				treeLastsome(5, tenDescendants);
				updated = false;
			}
			for (int i = 0; i < 5; i++)
				cout << tenDescendants[i] << endl;
			printf("...\n");
			for (int i = 9; i >= 5; i--)
				cout << tenDescendants[i] << endl;
		}
	}
};

struct Command
{
	Directory* tmpDir;
	int type;
	string arg;
	Command(string s)
	{
		for(int i=0;i<7;i++)
			if (CMDNAMES[i] == s)
			{
				type = i;
				if (i < 3)
					cin>>tmps, arg = tmps;
				return;
			}
	}
};

void solve()
{
	int n;
	scanf("%d", &n);
	Directory* now = new Directory("root", nullptr);
	vector<Command*> cmdList;
	while (n--)
	{
		cin>>tmps;
		Command* cmd = new Command(tmps);
		switch (cmd->type)
		{
			case 0:
				cmd->tmpDir = now->mkdir(cmd->arg);
				if (cmd->tmpDir == nullptr)
					printf("ERR\n");
				else
				{
					printf("OK\n");
					cmdList.push_back(cmd);
				}
				break;
			case 1:
				cmd->tmpDir = now->rm(cmd->arg);
				if (cmd->tmpDir == nullptr)
					printf("ERR\n");
				else
				{
					printf("OK\n");
					cmdList.push_back(cmd);
				}
				break;
			case 2:
			{ 
				Directory* ch = now->cd(cmd->arg);
				if (ch == nullptr)
					printf("ERR\n");
				else
				{
					printf("OK\n");
					cmd->tmpDir = now;
					now = ch;
					cmdList.push_back(cmd);
				}
				break;
			} 
			case 3:
				now->sz();
				break;
			case 4:
				now->ls();
				break;
			case 5:
				now->tree();
				break;
			case 6:
			{
				bool success = false;
				while (!success&&!cmdList.empty())
				{
					cmd = cmdList.back();
					cmdList.pop_back();
					switch (cmd->type)
					{
						case 0:
							success = (now->rm(cmd->arg) != nullptr);
							break;
						case 1:
							success = now->addChild(cmd->tmpDir);
							break;
						case 2:
							now = cmd->tmpDir;
							success = true;
							break;
					}
				}
				printf(success ? "OK\n" : "ERR\n");
			}
		}
	}
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
		solve();
    return 0; 
}