目录管理器2016-ACM（week9hw）

A - 咕咕东的目录管理器

题目

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

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

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

现在咕咕东可以在命令行下执行以下表格中描述的命令：输入
输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；

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

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

output
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
限制
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

代码

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
#include<map>
#include<string>
#include<string.h>
#include<vector>
using namespace std;

char tmps[50];//string类型不能scanf 
struct directory
{
	string name;
	map<string,directory*> children;//以便通过子目录名字取到子目录
	int subTreeSize;
	directory* parent;
	
	vector<string> tenDescen;//保存当前节点的是个后代
	bool updated;//是否已更新树 
	
	directory(string _name,directory* _parent)
	{
		name=_name;
		parent=_parent;
		subTreeSize=1;
	}
	
public:
	directory* mkdir(string name); 
	void maintain(int x);//向上维护子树大小 
	directory* rm(string name);
	directory* cd(string name);
	directory* getChild(string name);
	void sz();
	void ls();
	void tree();
	bool addChild(directory* d);
private:
	void treeAll(vector<string> *v);//将后代全部加入数组中 
	void treeFirstFive(int n,vector<string> *v);//将后代的前五个加入数组中
	void treeLastFive(int n,vector<string> *v);//将后代后五个加入数组中 

};
struct command
{
	const string commands[7]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
	int type;//类型
	string arg;//参数 
	directory* tmpDir;//记录各操作返回值 
	
	command(string s)
	{
		for(int i=0;i<7;i++)
			if(s==commands[i])
			{
				type=i;
				if(i<3)
				{
					scanf("%s",&tmps);
					arg=tmps;
					
				}
				return ;
			} 
	}
};

void solve()
{
	int q,co;
	scanf("%d",&q);
	directory* now=new directory("root",NULL);
	vector<command*> allCmd;//保存成功执行的操作，以便undo 
	while(q--)
	{
		scanf("%s",&tmps);
		command* cmd=new command(tmps);
		switch(cmd->type)
		{
			case 0://MADIR
				{
					cmd->tmpDir=now->mkdir(cmd->arg);
					if(cmd->tmpDir==NULL)printf("ERR\n");
					else
					{
						printf("OK\n");
						allCmd.push_back(cmd);
					}
				}
				break;
			case 1://RM
				{
					cmd->tmpDir=now->rm(cmd->arg);
					if(cmd->tmpDir==NULL)printf("ERR\n");
					else
					{
						printf("OK\n");
						allCmd.push_back(cmd);
					}
				}
				break;
			case 2://CD
				{
					directory* ch=now->cd(cmd->arg);
					if(ch==NULL)printf("ERR\n");
					else
					{
						printf("OK\n");
						cmd->tmpDir=now;//保留原有目录 
						now=ch;
						allCmd.push_back(cmd);
					}
				}
				break;
			case 3://SZ
				now->sz();break;
			case 4://LS
				now->ls();break;
			case 5://TREE
				now->tree();break;
			case 6://UNDO,撤销上一个成功执行的操作，操作仅限mkdir\rm\cd 
				{
					bool success=false;
					while(!success&&!allCmd.empty())
					{
						cmd=allCmd.back();allCmd.pop_back();
						switch(cmd->type)
						{
							case 0:
								{
									directory* t=now->rm(cmd->arg);
									if(t!=NULL)success=true;
								} 
								break;
							case 1:
								{
									success=now->addChild(cmd->tmpDir);
									
								}
								break;
							case 2:
								{
									now=cmd->tmpDir;
									success=true;
								}
								break;
						}
					}
					if(success)printf("OK\n");
					else printf("ERR\n");
				}
				break;
			
		}
	}
}

directory* directory::mkdir(string name)
{
	//成功返回子目录，否则返回空
	if(children.find(name)!=children.end())
		return NULL;
	directory* sub=new directory(name,this);
	children[name]=sub;
	maintain(1);
	return sub;
	
}
directory* directory::rm(string name)
{
	if(children.find(name)==children.end())
		return NULL;
	std::map<string,directory*>::iterator it=children.find(name);
	maintain(-1*it->second->subTreeSize);
	children.erase(it);
	return it->second;
}

directory* directory::cd(string name)
{
	if(name=="..")
		return this->parent;
	return getChild(name);
	
}
directory* directory::getChild(string name)
{
	std::map<string,directory*>::iterator it=children.find(name);
	if(it==children.end())return NULL;
	return it->second;
}

void directory::ls()
{
	int s=children.size();
	if(s==0)printf("EMPTY\n");
	else if(s<=10)
		for(std::map<string,directory*>::iterator it=children.begin();it!=children.end();it++)
			printf("%s\n",it->first.c_str());
	else
	{
		std::map<string,directory*>::iterator it=children.begin();
		for(int i=0;i<5;i++,it++)
			printf("%s\n",it->first.c_str());
		printf("...\n");
		it=children.end();
		for(int i=0;i<5;i++,it--);
		for(int i=0;i<5;i++,it++)
			printf("%s\n",it->first.c_str());
		
	}
}

void directory::sz()
{
	printf("%d\n",this->subTreeSize);
}
void directory::maintain(int x)
{
	updated=true;
	subTreeSize+=x;
	if(parent!=NULL)
		parent->maintain(x);
}

bool directory::addChild(directory* d)
{
	if(children.find(d->name)!=children.end())
		return false;
	children[d->name]=d;
	maintain(d->subTreeSize);
	return true;
}

void directory::tree()
{
	//缓存（懒更新）
	if(subTreeSize==1)printf("EMPTY\n");
	else if(subTreeSize<=10)
	{
		if(updated)//已更新
		{
			tenDescen.clear();
			
			treeAll(&tenDescen);//将后代全部加入数组
			updated=false;
			 
		}
		for(int i=0;i<subTreeSize;i++)
			printf("%s\n",tenDescen.at(i).c_str()); 
	}
	else 
	{
		if(updated)
		{
			tenDescen.clear();
			treeFirstFive(5,&tenDescen);
			treeLastFive(5,&tenDescen);
			updated=false;
		}
		for(int i=0;i<5;i++)
			printf("%s\n",tenDescen.at(i).c_str());
		printf("...\n");
		for(int i=9;i>=5;i--)
			printf("%s\n",tenDescen.at(i).c_str()); 
	}
	 
}
void directory::treeAll(vector<string>* v)
{
	v->push_back(name);
	
	
	for(std::map<string,directory*>::iterator it=children.begin();it!=children.end();it++)
		it->second->treeAll(v);
}

void directory::treeFirstFive(int n,vector<string>* v)
{
	v->push_back(name);
	if(--n==0)return;
	int s=children.size();
	std::map<string,directory*>::iterator it=children.begin();
	while(s--)
	{
		int st=it->second->subTreeSize;
		if(st>=n)
		{
			it->second->treeFirstFive(n,v);
			return;
		}
		else
		{
			
			it->second->treeFirstFive(st,v);
			n-=st;
		}
		it++;
	}
} 


void directory::treeLastFive(int n,vector<string>* v)
{
	
	int s=children.size();
	std::map<string,directory*>::iterator it=children.end();
	while(s--)
	{
		it--;
		int st=it->second->subTreeSize;
		if(st>=n)
		{
			it->second->treeLastFive(n,v);
			return;
		}
		else
		{
			
			it->second->treeLastFive(st,v);
			
			n-=st;
		}
		
	}
	v->push_back(name);
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
		solve();
	return 0;
}