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”

输入输出

Input

输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；
每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；
每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。

Output

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

Sample Input

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

Sample Output

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

思路分析

这道题是很大块的题目，题面很长且分多种情况，明白大概后可以先将问题划分成有结构的几部分，比如就先从程序入口开始写，再写一个solve()函数填充起框架。
接下来考虑将不同命令封装起来，定义一个目录结构体，将不同的命令操作封装起来。然后按照要求分别定义具体的命令操作函数。在solve（）函数内转向不同的命令操作。
UNDO比较特殊，需要单独考虑。关键问题是：1.必须是MKDIR、RM、CD三种之一；2.必须已经执行成功。如果UNDO，需要保存每条指令执行的结果，用结构体command存储。
最后要实现TREE命令时，在后代节点数量大于10时，要开始前序遍历和后序遍历，要注意复杂度要求。解决方法是缓存，即懒更新，节点数远少于TREE操作数，指不定还有重复询问，对于目录相同期间问过的相同问题，理应只有一次是计算过程。

总结反思

遇到这种复杂的题目时先不要慌，采取自顶向下的思路，首先根据题目的任务需求设计编程框架，包括规划结构体封装、声明相关函数等；然后再根据具体要求对框架进行填充，考虑算法复杂度等问题。

AC代码

#include<iostream>
#include<string>
#include<map>
#include<vector>
using namespace std;

const int maxn=1e5+5;
const string op[]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"}; 
int t;
struct dir{
    string name;   //当前目录的名字
    dir *par;
    int subz; //子树大小
    map<string,dir*> child; //维护树形结构
    vector<string> tenDe;//当前节点的十个后代
    bool update; //记录当前节点的子树有无变动，无变动则“十个后代”无需更新
    dir(string name)
    {
        this->name=name;
        par=NULL;
        subz=1;
    }
    dir *getChild(string name) //取子目录并返回，不存在则返回空指针
    {
        auto it=child.find(name);
        if(it==child.end())
            return NULL;
        return it->second;  
    }
    void maintain(int delta)//向上维护子树大小
    {
        this->update=true;
        subz+=delta;
        if(par!=NULL)
            par->maintain(delta);
    }
    dir *mkdir(string name) //创建子目录并返回，创建失败返回空指针
    {
        if(child.find(name)!=child.end())
            return NULL;
        dir* ch=new dir(name);
        ch->par=this;
        child[name]=ch;
        maintain(1);
        return ch;
    } 
    dir *rm(string name) //删除子目录并返回，删除失败返回空指针
    {
        auto it=child.find(name);
        if(it==child.end())
            return NULL;
        maintain(-1*it->second->subz);
        dir*temp=it->second;
        child.erase(it);
        return temp;  
    }
    dir*cd(string name)
    {
        if(".."==name)
            return par;
         return getChild(name);
    }
    bool addChild(dir *ch)//加入子目录并返回成功与否
    {
        if(child.find(ch->name)!=child.end())
            return false; 
        child[ch->name]=ch;
        maintain(ch->subz);
        return true;  
    }
    void sz()
    {
        printf("%d\n",subz);
    }
    void ls()
    {
        int size=child.size();
        if(size==0)
            printf("EMPTY\n");
        else if(size<=10)
        {
            for(auto it=child.begin();it!=child.end();it++)
                cout<<it->first<<endl;
        }
        else{
              auto it=child.begin();
              for(int i=0;i<5;i++,it++)
                  cout<<it->first<<endl;
              printf("...\n");
              it=child.end();
              for(int i=0;i<5;i++)it--;
              for(int i=0;i<5;i++,it++)
                  cout<<it->first<<endl;
         }  
    }
    void treeAll(vector<string>& bar)
    {//全部后代加入桶
        bar.push_back(name);
        for(auto it=child.begin();it!=child.end();it++)
            it->second->treeAll(bar);
    }
    void treeFirst(int num,vector<string>& bar)
    {//前序遍历并加入首要的num个后代
        bar.push_back(name);
        if(--num==0) return;
        int n=child.size();
        auto it=child.begin();
        while(n--)
        {
            int sts=it->second->subz;
            if(sts>=num)
            {
               it->second->treeFirst(num,bar);
               return;
            }
            else{
                it->second->treeFirst(sts,bar);
                num-=sts;
            }
            it++;
        }
    }
    void treeLast(int num,vector<string>& bar)
    {//后序遍历并加入首要的num个后代
        int n=child.size();
        auto it=child.end();
        while(n--)
        {
            it--;
            int sts=it->second->subz;
            if(sts>=num)
            {
                it->second->treeLast(num,bar);
                return;  
            }
            else{
               it->second->treeLast(sts,bar);
               num-=sts;
            }
        }
        bar.push_back(name);
    }
    void tree()
    {
        if(subz==1)
            printf("EMPTY\n");
        else if(subz<=10)
        {
            if(update)
            {
                tenDe.clear();
                treeAll(tenDe);
                update=false;
            }
            for(auto it=tenDe.begin();it!=tenDe.end();it++)
                cout<<*it<<endl;
        }
        else{
            if(update)
            {
                tenDe.clear();
                treeFirst(5,tenDe);
                treeLast(5,tenDe);
                update=false;
             }
             for(int i=0;i<5;i++)
                 cout<<tenDe[i]<<endl;
             printf("...\n");
             for(int i=9;i>=5;i--)
                 cout<<tenDe[i]<<endl;
         }
    }
};

struct Cmd{
    int type;
    string arg;
    dir *hiscmd; //记录刚刚操作设计的目录节点
    void init(string s)
    {
        for(int i=0;i<7;i++)
        {
            if(s==op[i])
            {
                type=i;
                if(i<3) cin>>arg;
                return;   
             }
          }  
      }
}cmd[maxn];
int cnt=-1;
string tmp;
vector<int> cmdlist;
dir* now=NULL;
void solve()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
  //scanf("%s",tmp);
        cin>>tmp;
        cnt++;
        cmd[cnt].init(tmp);
        switch(cmd[cnt].type)
        {
            case 0:
                cmd[cnt].hiscmd=now->mkdir(cmd[cnt].arg);
                if(cmd[cnt].hiscmd==NULL)
		     printf("ERR\n");
		else
		     printf("OK\n"),cmdlist.push_back(cnt);
		break;
	     case 1:
		    cmd[cnt].hiscmd=now->rm(cmd[cnt].arg);
		    if(cmd[cnt].hiscmd==NULL)
		        printf("ERR\n");
		    else
		        printf("OK\n"),cmdlist.push_back(cnt);
		    break;
	    case 2:
		dir*ch=now->cd(cmd[cnt].arg);
		if(ch==NULL)printf("ERR\n");
		else{
		     printf("OK\n");
		     cmd[cnt].hiscmd=now;
		     now=ch;
		     cmdlist.push_back(cnt);
		}
		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())
    		{
     		    int n=cmdlist.back();
     		    cmdlist.pop_back();
     		    switch(cmd[n].type)
     		    {
     			case 0:success=(now->rm(cmd[n].arg)!=NULL);break;
      			case 1:success=now->addChild(cmd[n].hiscmd);break;
      			case 2:now=cmd[n].hiscmd;success=true;break;
     		    }
    	    	}
     		printf(success?"OK\n":"ERR\n");
 	    }
  	}
    }
}

int main()
{
    cin>>t;
    while(t--)
    {
  	cmdlist.clear();
  	cnt=-1;
  	now=new dir("root");
  	solve();
    }
    return 0;
}