week9-咕咕东的目录管理器

问题描述
咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零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：
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。

样例输入
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
样例输出
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

解题思路：

对于这一个题，所涉及的操作比较多，所以首先我们应该确定一个解题框架。首先，一个目录可能有多个子目录，并且要保证按字典序进行排序，如果使用vector的话，尽管能够实现存储多个孩子，但是不能实现字典序有序， 还要进行一步排序。如果采用map，一个目录名映射到一个目录指针，我们可以通过目录名很快的找到该指针，时间为log级，并且map会有按第一维自动排序的功能，所以只要加入map，它就能保证其first有序。并且其中还有一个指针指向其父亲，和一个int型的变量size，来表示以这个目录为根的所有目录的个数。由于输入由一系列指令构成，所以我们也用一个结构体来存储指令，才读入一个指令之后，按其对应的字符串，将其转换为相应的int，如果为前三条指令，即mkdir，rm，cd，则指令后面还有一个参数，则要读入并将其存在一个string类型的变量中。考虑到操作中有undo操作，所以还要一个变量来存储刚刚涉及的目录节点。

在大致考虑完存储之后，则考虑操作大致框架。对于mkdir操作，则是在当前目录下创建一个新目录，所以我们需要一个指针now来指向当前目录，初始值为root。在创建成功之后，返回刚刚创建的目录的指针，如果指针不为空，则创建成功，将刚刚执行成功的这条指令加入到一个vector对象中， 该对象存储已经成功执行的命令。在rm操作，和mikdir操作的框架差不多。在cd操作中，进入一个新目录，在操作成功后，更改now指针的指向。对于后三个操作，sz，ls，tree，直接调用函数，不需要其他改变。后面具体说明这些函数。对于undo操作，则从vector中取出一条最近执行成功的指令，如果为mkdir，则将新建的目录删除，如果为rm，则将之前删除的目录加上，如果为cd，则返回上一级。

在大致框架考虑完之后，则考虑每一步的具体的操作，对于mkdir操作，则是现在当前目录下查找要添加的目录，没有再进行添加，并且向上维护每一个目录的size值。对于rm操作，也是首先查找，当找到之后再进行删除，连同其孩子一并删除，并且向上维护个目录的size值。对于cd操作，则我们先判断是否参数为"…"，如果是，则进入父亲目录，否则进入子目录。对于sz操作，直接返回结构体中的size。对于ls操作，则要首先判断当前目录下有几个子目录，如果小于10个，则全部输出，否则输出前5个和后5个，中间用"…"隔开。为了配个undo，还有一个操作时将删除的目录添加上，和mkdir操作的思想差不多。在进行许多操作时，都有一个维护目录的size值操作，其实从当前目录向上维护，一直到根节点。

对于最后一个操作tree，如果我们执行tree操作都将整个文件目录遍历一遍，通过分析数据范围肯定会超时。在有些情况下是不需要重新遍历，比如两次tree操作时的目录结构相同，则我们直接输出上次调用tree的结果就可以。则我们可以通过一个bool类型的变量来标记文件目录在一次tree操作后是否更改过。如果没有更改过，则直接输出已经保存好的结果。如果更改过，则要对文件目录进行遍历，如果该文件下的目录个数小于10个，则直接进行遍历，将结果存在vector中。如果目录个数大于10个，则我们只需要前5个和后5个，所以需两个遍历函数来分别进行操作，第一次遍历得到前5个目录，第二次遍历得到后5个目录。

代码：

#include<iostream>
#include<map>
#include<vector>
using namespace std;
struct dir{//目录结构体
    string name;//目录名
    map<string,dir*> children;//孩子
    dir *parent;//父亲
    int size;//以当前目录为根的目录的个数
    bool update;//是否更新过
    vector<string> tendes;//存储遍历时的孩子
    dir(string na,dir *p)
    {
        size=1;
        name=na;
        parent=p;
    }
public:
    dir* getchild(string mu)
    {//得到目录名为mu的孩子
        map<string,dir*>::iterator it=children.find(mu);
        if(it==children.end())
            return NULL;
        else
            return it->second;
    }
    dir* mkdir(string mu)
    {//创建目录
        if(children.find(mu)!=children.end())
            return NULL;
        dir *te=new dir(mu,this);
        children[mu]=te;
        maintain(1);
        return te;
    }
    dir* rm(string mu)
    {//删除目录
        map<string,dir*>::iterator it=children.find(mu);
        if(it==children.end())
            return NULL;
        maintain(-1*it->second->size);
        children.erase(it);
        return it->second;
    }
    dir* cd(string mu)
    {//进入目录
        if(mu=="..")
            return this->parent;
        return getchild(mu);
    }
    bool addchild(dir *ch)
    {//将刚刚删除的子目录添加上
        if(children.find(ch->name)!=children.end())
            return false;
        children[ch->name]=ch;    
        maintain(+ch->size);
        return true;
    }
    void maintain(int s)
    {//维护整个文件目录的size
        update=true;
        size+=s;
        if(parent!=NULL)
            parent->maintain(s);
    }
    void sz()
    {//输出size
        cout<<size<<endl; 
    }
    void ls()
    {//得到该文件下的所有文件夹
        int ss=children.size();
        if(ss==0)
            cout<<"EMPTY"<<endl;
        else if(ss<=10)
        {
            map<string,dir*>::iterator it=children.begin();
            while(it!=children.end())
            {
                cout<<it->first<<endl;
                it++;
            }
        }
        else
        {
            map<string,dir*>::iterator it=children.begin();
            for(int i=0;i<5;i++,it++)
                cout<<it->first<<endl;
            cout<<"..."<<endl;
            it=children.end();
            for(int i=0;i<5;i++) it--;
            for(int i=0;i<5;i++,it++)
                cout<<it->first<<endl;
        }
    }
    void tree()
    {//得到整个树形结构
        if(size==1) cout<<"EMPTY"<<endl;
        else if(size<=10)
        {
            if(update)//未更新过
            {
                tendes.clear();
                treeall(&tendes);
                update=false;
            }
            for(int i=0;i<size;i++)
                cout<<tendes[i]<<endl;
        }
        else
        {
            if(update)
            {
                tendes.clear();
                treef(5,&tendes);
                treel(5,&tendes);
                update=false;
            }
            for(int i=0;i<5;i++)
                cout<<tendes[i]<<endl;
            cout<<"..."<<endl;
            for(int i=9;i>=5;i--)
                cout<<tendes[i]<<endl;
        }
    }
private:
    void treeall(vector<string> *v)
    {//遍历所有节点
        v->push_back(name);
        map<string,dir*>::iterator it=children.begin();
        while(it!=children.end())
        {
            it->second->treeall(v);
            it++;
        }
    }
    void treef(int n,vector<string> *v)
    {//遍历前5个节点
        v->push_back(name);
        if(--n==0) return;
        int nn=children.size();
        map<string,dir*>::iterator it=children.begin();
        while(nn--)
        {
            int ss=it->second->size;//得到每一个孩子的目录的大小
            if(ss>=n)
            {//如果大于所需要的
                it->second->treef(n,v);//遍历完其孩子就可以返回
                return;
            }
            else
            {//否则还有继续遍历
                it->second->treef(ss,v);
                n-=ss; 
            }
            it++;
        }
    }
    void treel(int n,vector<string> *v)
    {//遍历后五个节点
        int nn=children.size();
        map<string,dir*>::iterator it=children.end();
        while(nn--)
        {//和遍历前5个的思想类似
            it--;
            int ss=it->second->size;
            if(ss>=n)
            {
                it->second->treel(n,v);
                return;
            }
            else
            {
                it->second->treel(ss,v);
                n-=ss;
            }
            
        }
        v->push_back(name);
    }
};
char ming[30];
struct com{//命令结构体
    string commands[7]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
    int type;
    string can;
    dir* tdir;//刚刚涉及的目录节点 
    com(string tem)
    {
        for(int i=0;i<7;i++)
        {
            if(commands[i]==tem){
                type=i;
                if(i<3){
                    cin>>ming;
                    can=ming;
                }
                return;
            }
        }
    }
    
};
void solve()
{
    int Q;
    cin>>Q;
    dir *now=new dir("root",NULL); 
    vector<com*> comlist;
    for(int i=0;i<Q;i++)
    {//进行各个操作
        cin>>ming;
        com *c=new com(ming);
        if(c->type==0)
        {
            c->tdir=now->mkdir(c->can);
            if(c->tdir==NULL)
                cout<<"ERR"<<endl;
            else
            {
                cout<<"OK"<<endl; 
                comlist.push_back(c);
            }
        }     
        else if(c->type==1)
        {
            c->tdir=now->rm(c->can);
            if(c->tdir==NULL)
                cout<<"ERR"<<endl;
            else
            {
                cout<<"OK"<<endl; 
                comlist.push_back(c);
            }
        }
        else if(c->type==2)
        {
            dir *te=now->cd(c->can);
            if(te==NULL)
                cout<<"ERR"<<endl;
            else
            {
                cout<<"OK"<<endl;
                c->tdir=now;
                now=te;
                comlist.push_back(c);    
            }
        }
            
        else if(c->type==3)
            now->sz();
        else if(c->type==4)
            now->ls();
        else if(c->type==5)
            now->tree();
        else if(c->type==6)
        {
            bool su=false;
            while(!su&&!comlist.empty())
            {
                c=comlist.back();
                comlist.pop_back();
                if(c->type==0)
                {
                    dir *temp=now->rm(c->can);
                    if(temp!=NULL) su=true;
                }
                else if(c->type==1)
                    su=now->addchild(c->tdir);
                else if(c->type==2)
                {
                    now=c->tdir;
                    su=true;
                }
            }
            if(su) cout<<"OK"<<endl;
            else cout<<"ERR"<<endl;
        }  
    }
}
int main()
{
    int T;
    cin>>T;
    for(int i=0;i<T;i++)
    {
        solve();
    }    
}