本文详细介绍了一种高效目录管理器的设计与实现过程，包括面向对象编程思想的应用、命令解析与执行、目录树结构的维护及撤销操作等功能。文章深入探讨了如何优化TREE命令的执行效率，以及如何在撤销操作时保持数据一致性。
问题描述
咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零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
求解思路
- 严格面向对象编程，创建command对象来保存命令，directory对象保存目录
- command结构体的数据成员有：
Directory* tmpDir;//记录刚刚操作设计的目录节点
const string COMMANDNAMES[7] = { "MKDIR","RM","CD","SZ","LS","TREE","UNDO" };
int type;//命令类型
string commandstr;//命令参数
其中，tmpDir记录该命令操作的目录节点
COMMANDNAMES数组将命令转换为整数编号
type记录该命令的编号
commandstr用来记录"MKDIR",“RM”,"CD"的参数
- directory的数据成员有：
bool updated;//当前十个后代是否为更新后的
string name;//当前目录的名字
map<string, Directory*>children;//使用指针避免复制构造造成的内存浪费
Directory* parent;//CD ..返回上级目录
int subtreeSize;//sz输出子树大小
vector<string>* tenDescendants;//记录十个后代
tenDescendants用于记录前五个和后五个后代，通过缓存的方式，降低TREE命令的时间复杂度，
updated用于记录当前tenDescendants中记录的是否为最新的后代，当进行mkdir和rm操作时，tenDescendants可能需要更新。
map<string, Directory*>children用来记录每个目录节点的儿子节点，并保持字典序。
parent记录当前结点的父节点
subtreeSize记录子树的大小。
- 创建
vector<Command*> cmdList;每次读入一个命令，就对该命令操作的目录对象调用相应的函数。若该命令为 “MKDIR”,“RM”,“CD”，则将对应的命令保存在vector<Command*> cmdList中，以备undo时的还原。 - 对于TREE命令，若updated为真，则需要重新确定后代，若后代数量小于十，调用treeAll(tenDescendants)函数，采用递归遍历的方式遍历所有结点
void treeAll(vector<string>* vbar)
{//更新全桶
vbar->push_back(name);
for (auto& entry : children)
entry.second->treeAll(vbar);
}
- 若后代数量大于十，分别调用treeFirstSome和treeLastSome函数计算前五个与后五个后代，需要对当前结点的孩子是否大于需要节点数目进行分开处理。
void treeFirstSome(int num, vector<string>* vbar)
{//更新前序几个
vbar->push_back(name);
if (--num == 0)return;
int n = children.size();
//map<string, Directory*>::iterator it = children.begin();
auto it = children.begin();
for (int i = 0; i < n; i++)
{
int sts = it->second->subtreeSize;
if (sts >= num)
{
it->second->treeFirstSome(num, vbar);
return;
}
else
{
it->second->treeFirstSome(sts, vbar);
num = num - sts;
}
it++;
}
}
void treeLastSome(int num, vector<string>* vbar)
{
int n = children.size();
// map<string, Directory*>::iterator it = children.end();
auto it = children.end();
for (int i = 0; i < n; i++)
{
it--;
int sts = it->second->subtreeSize;
if (sts >= num)
{
it->second->treeLastSome(num, vbar);
return;
}
else
{
it->second->treeLastSome(sts, vbar);
num -= sts;
}
}
vbar->push_back(name);
}
代码
#include<iostream>
#include<algorithm>
#include<string.h>
#include<map>
#include<vector>
#include<cstring>
#include<string>
using namespace std;
struct Directory
{
bool updated;//当前十个后代是否为更新后的
string name;//当前目录的名字
map<string, Directory*>children;//使用指针避免复制构造造成的内存浪费
Directory* parent;//CD ..返回上级目录
int subtreeSize;//sz输出子树大小
vector<string>* tenDescendants;//记录十个后代
Directory()
{
tenDescendants = new vector<string>;
this->updated = true;
parent = new Directory();
}
Directory(string name, Directory* parent)
{
this->name = name;
this->parent = parent;
this->subtreeSize = 1;
//updated = true;
tenDescendants = new vector<string>;
}
void treeAll(vector<string>* vbar)
{//更新全桶
vbar->push_back(name);
for (auto& entry : children)
entry.second->treeAll(vbar);
}
void treeFirstSome(int num, vector<string>* vbar)
{//更新前序几个
vbar->push_back(name);
if (--num == 0)return;
int n = children.size();
//map<string, Directory*>::iterator it = children.begin();
auto it = children.begin();
for (int i = 0; i < n; i++)
{
int sts = it->second->subtreeSize;
if (sts >= num)
{
it->second->treeFirstSome(num, vbar);
return;
}
else
{
it->second->treeFirstSome(sts, vbar);
num = num - sts;
}
it++;
}
}
void treeLastSome(int num, vector<string>* vbar)
{
int n = children.size();
// map<string, Directory*>::iterator it = children.end();
auto it = children.end();
for (int i = 0; i < n; i++)
{
it--;
int sts = it->second->subtreeSize;
if (sts >= num)
{
it->second->treeLastSome(num, vbar);
return;
}
else
{
it->second->treeLastSome(sts, vbar);
num -= sts;
}
}
vbar->push_back(name);
}
public:
Directory* getChild(string name)
{
auto it = children.find(name);
if (it == children.end())
return NULL;
return it->second;
}
Directory* mkdir(string name)
{
if (children.find(name) != children.end())
return NULL;
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 NULL;
maintain(-1 * it->second->subtreeSize);
//Directory* temp = it->second;
children.erase(it);//??
//return temp;
return it->second;
}
Directory* cd(string name)
{
//updated = true;
if (name == "..")
{
return this->parent;
}
return getChild(name);
}
void sz()
{
printf("%d\n", this->subtreeSize);
}
void ls()
{
int sz = children.size();
if (sz == 0)
{
printf("EMPTY\n");
return;
}
if (sz <= 10)
{
for (auto& entry : children)
printf("%s\n", entry.first.c_str());
}
else if (sz > 10)
{
// map<string, Directory*>::iterator it = children.begin();
auto 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());
}
}
bool addChild(Directory* ch)
{
if (children.find(ch->name) != children.end())
return false;//有这个名字
children[ch->name] = ch;
maintain(+ch->subtreeSize);
return true;
}
void maintain(int delta)//向上维护子树大小
{
updated = true;
subtreeSize = subtreeSize + delta;
if (parent != NULL)
parent->maintain(delta);
}
void tree()
{
if (subtreeSize == 1)
{
printf("EMPTY\n");
return;
}
if (subtreeSize <= 10)
{
if (this->updated)
{
tenDescendants->clear();
treeAll(tenDescendants);
this->updated = false;
}
for (int i = 0; i < subtreeSize; i++)
printf("%s\n", tenDescendants->at(i).c_str());
}
else
{
if (this->updated)
{
tenDescendants->clear();
treeFirstSome(5, tenDescendants);
treeLastSome(5, tenDescendants);
this->updated = false;
}
for (int i = 0; i < 5; i++)
printf("%s\n", tenDescendants->at(i).c_str());
printf("...\n");
for (int i = 9; i >= 5; i--)
printf("%s\n", tenDescendants->at(i).c_str());
}
}
};
struct Command
{
Directory* tmpDir;//记录刚刚操作设计的目录节点
const string COMMANDNAMES[7] = { "MKDIR","RM","CD","SZ","LS","TREE","UNDO" };
int type;//命令类型
string commandstr;//命令参数
Command(string s)
{
this->type = -1;
for (int i = 0; i < 7; i++)
if (COMMANDNAMES[i] == s)
{
this->type = i;
if (i < 3)//MKDIR,RM,CD的后续参数读入
{
//char tmps[20];
string tmps;
cin >> tmps;
// scanf_s("%s", tmps);
this->commandstr = tmps;
}
return;
}
}
};
//vector<Command*> cmdList;//记录命令
void solve()
{
// cmdList.clear();
int n;
//scanf_s("%d", &n);
cin >> n;
vector<Command*> cmdList;
Directory* current = new Directory("root", NULL);
for (int i = 0; i < n; i++)
{
//char tmps[20];
string tmps;
cin >> tmps;
// scanf_s("%s", tmps);
Command* cmd = new Command(tmps);
switch (cmd->type)
{
case 0:
{
cmd->tmpDir = current->mkdir(cmd->commandstr);
if (cmd->tmpDir == NULL)
printf("ERR\n");
else
{
printf("OK\n");
cmdList.push_back(cmd);
}
break;
}
case 1:
{
cmd->tmpDir = current->rm(cmd->commandstr);//
if (cmd->tmpDir == NULL)
printf("ERR\n");
else
{
printf("OK\n");
cmdList.push_back(cmd);
}
break;
}
case 2:
{
Directory* ch = current->cd(cmd->commandstr);
if (ch == NULL)
printf("ERR\n");
else
{
printf("OK\n");
cmd->tmpDir = current;
current = ch;
cmdList.push_back(cmd);
}
break;
}
case 3:current->sz(); break;
case 4:current->ls(); break;
case 5:current->tree(); break;
case 6://undo
{
bool success = false;
while (!success && !cmdList.empty())
{
cmd = cmdList.back();
cmdList.pop_back();
switch (cmd->type)
{
//case 0: {if (current->rm(cmd->commandstr) != NULL) success = true; break; }
case 0: success = current->rm(cmd->commandstr) != NULL; break;
case 1: {success = current->addChild(cmd->tmpDir); break; }
case 2: {
current = cmd->tmpDir;
success = true; //啊啊啊啊啊啊啊啊啊啊啊啊
break;
}
default:
break;
}
}
cout << (success ? "OK" : "ERR") << endl;
//if (success == true) printf("OK\n");
//else printf("ERR\n");
}
}
}
}
int main()
{
int T;
//scanf_s("%d", &T);
cin >> T;
for (int i = 0; i < T; i++)
{
solve();
// if (i != T - 1)
// cout << endl;
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
