Week9：目录管理器

最新推荐文章于 2024-08-08 18:39:04 发布

江正正

最新推荐文章于 2024-08-08 18:39:04 发布

阅读量147

点赞数

本文链接：https://blog.csdn.net/qq_44506233/article/details/106670317

版权

题目描述

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

解题思路

一个巨型模拟题，要求实现目录管理器的功能。使用自顶向下的思路，先视为已经写好了某一模块，然后再去实现具体细节。
目录管理器是一个树形结构，因此需要定义树的节点结构体，每个结构体都包含有：

节点名
孩子列表
父节点
子树大小（对应题目中的子目录大小）

由于题目中描述的操作都是以当前目录为基准的，所以我们在每个节点中直接写上相应操作的函数，由此结构体变为了类。

特殊的，Undo操作不属于某一个节点，是全局的，这一条单独拎出来考虑：

由于撤销的只可能是一个操作，故我们只需要对执行过的操作储存到一个表中，撤销时从后往前找到第一个成功执行过的操作，然后对其进行逆操作即可，表现为原先创建就删除，原先删除就创建，原先进目录就出目录…

也正是由此，我们进行操作的时候不需要直接真正意义上的删除或者什么的，只需要断开指针之间的连接即可，这样，恢复的时候只需要直接连起来就行了（这里需要注意不要弄出空指针和野指针）

各个函数的具体实现见代码，思路不难，代码中对操作都做了注释。
（写代码的时候输入法出了问题，所以注释用的是龙鸣英语）

难点核心在于Tree的打印。

Tree指令的出现次数约为1e5，而我们整棵树的节点最多也不过5e3，因此在目录不变的时候我们并不需要每次都重新遍历一遍，过于消耗时间了。答案是懒更新。

详细见代码：
（危三百七十多行危）
在这里插入图片描述

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

using namespace std;

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

class Node;

class Command
{
public:
	int type;//the type of this command
	string arg;//arg for MKDIR,RM and CD
	Node* lastOperation;//storage of laseOperation

	Command(string s)
	{
		for (int i = 0; i <= 6; i++)
		{
			if (cmdname[i] == s)
			{
				type = i;
				if (i <= 2)
					cin >> arg;
				return;
			}
		}
	}
};

class Node
{
public:
	Node(string name, Node* father)
	{
		this->name = name;
		this->father = father;
		this->size = 1;
		this->isupdating = false;
		this->childToShow = new vector<string>;
	}

	Node* mkdir(string arg);//return the node that inserted
	Node* rm(string arg);//return the node that deleted
	Node* cd(string arg);//return the dir used to stay
	void sz();//return the size of the subtree
	void ls();//show the direct children of this node
	void tree();//show the subtree of this node

	bool addChild(Node* node);//insert node into the list of child
	void updatesize(int num);//Update all the father's size

private:
	string name;//name of this Node
	map<string, Node*>child;//List of child，use the name of the child to find the child node
	Node* father;//the father Node of this
	int size;//size of the subtree
	bool isupdating;//if is updating

	vector<string>* childToShow;//the children that need to show
	void updateTheTree(int type, int num, vector<string>* childToShow);//update the tree
};

Node* Node::mkdir(string arg)
{
	if (child.find(arg) != child.end())//Has existed
	{
		return NULL;
	}

	Node* new_node = new Node(arg, this);
	child.insert({ arg,new_node });//insert into the list

	updatesize(1);//update the size of all the father nodes

	return new_node;//return the node created just now
}

Node* Node::rm(string arg)
{
	auto tmp = child.find(arg);
	if (tmp == child.end())//Hasn't existed
	{
		return NULL;
	}

	Node* the_node = tmp->second;//get the node that is going to delete
	child.erase(tmp);//delete it

	updatesize(-1 * the_node->size);//update the size of all the father nodes

	return the_node;//return the node deleted just now
}

Node* Node::cd(string arg)
{
	if (arg == "..")
	{
		return this->father;//return the father node
	}
	else
	{
		auto tmp = child.find(arg);
		if (tmp == child.end())//Hasn't existed
		{
			return NULL;
		}

		return tmp->second;//return the child node
	}
}

void Node::ls()
{
	int the_size = child.size();
	if (!the_size)
	{
		cout << "EMPTY" << endl;
	}
	else if (the_size >= 1 && the_size <= 10)
	{
		for (auto i : child)
		{
			cout << i.first << endl;
		}
	}
	else
	{
		auto iterbegin = child.begin();
		auto iterend = child.end();
		for (int i = 0; i < 5; i++)
		{
			cout << iterbegin->first << endl;
			iterbegin++;
			iterend--;
		}
		cout << "..." << endl;
		for (int i = 0; i < 5; i++)
		{
			cout << iterend->first << endl;
			iterend++;
		}
		
	}
}

void Node::sz()
{
	cout << this->size << endl;
}

bool Node::addChild(Node* node)
{
	if (child.find(node->name) != child.end())//Has existed
	{
		return false;
	}

	child.insert({ node->name,node });//insert the node
	updatesize(node->size);//update the size of all the father nodes

	return true;
}

void Node::updatesize(int num)
{
	this->isupdating = true;
	this->size += num;
	if (this->father != NULL)//if this node isn't "root"
	{
		this->father->updatesize(num);//itrater to update the size of the father node
	}
}

void Node::tree()
{
	if (this->size == 1)
		cout << "EMPTY" << endl;
	else if (this->size > 1 && this->size <= 10)
	{
		if (this->isupdating)//if the node has changed just now
		{
			childToShow->clear();
			updateTheTree(0, 0, childToShow);
			this->isupdating = false;
		}
		for (int i = 0; i < this->size; i++)
		{
			cout << childToShow->at(i) << endl;
		}
	}
	else
	{
		if (this->isupdating)
		{
			childToShow->clear();
			updateTheTree(1, 5, childToShow);
			updateTheTree(2, 5, childToShow);
			this->isupdating = false;
		}
		for (int i = 0; i < 5; i++)
		{
			cout << childToShow->at(i) << endl;
		}
		cout << "..." << endl;
		for (int i = 9; i >= 5; i--)
		{
			cout << childToShow->at(i) << endl;
		}
	}
}

//type:0-all,1-front,2-back
void Node::updateTheTree(int type, int num, vector<string>* childToShow)
{
	if (type == 0)
	{
		childToShow->push_back(this->name);
		for (auto i : child)
		{
			i.second->updateTheTree(0, 0, childToShow);
		}
	}
	if (type == 1)
	{
		childToShow->push_back(this->name);
		if (--num == 0) return;

		int n = child.size();
		auto it = child.begin();

		while (n--)
		{
			int sts = it->second->size;
			if (sts >= num)
			{
				it->second->updateTheTree(1, num, childToShow);
				return;
			}
			else
			{
				it->second->updateTheTree(1, sts, childToShow);
				num -= sts;
			}
			it++;
		}
	}
	if (type == 2)
	{
		int n = child.size();
		auto it = child.end();
		while (n--)
		{
			it--;
			int sts = it->second->size;
			if (sts >= num)
			{
				it->second->updateTheTree(2, num, childToShow);
				return;
			}
			else
			{
				it->second->updateTheTree(2, sts, childToShow);
				num -= sts;
			}
		}

		childToShow->push_back(this->name);
	}

}

vector<Command*> cmdList;

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);

	int t, n;
	cin >> t;
	string thecmd;
	while (t--)
	{
		Node* now = new Node("root", NULL);//start in root
		cmdList.clear();

		cin >> n;
		while (n--)
		{
			cin >> thecmd;//the name of the command
			Command* cmd = new Command(thecmd);
			switch (cmd->type)
			{
			case 0:case 1:
			{
				cmd->lastOperation = (cmd->type == 0 ? now->mkdir(cmd->arg) : now->rm(cmd->arg));//Get the returnd value
				if (cmd->lastOperation == NULL)//if illegal
				{
					cout << "ERR" << endl;
				}
				else
				{
					cout << "OK" << endl;
					cmdList.push_back(cmd);//push cmd into the list of commands
				}
				break;
			}
			case 2:
			{
				Node* temp = now->cd(cmd->arg);//Get the returnd value:target directory
				if (temp == NULL)
				{
					cout << "ERR" << endl;
				}
				else
				{
					cout << "OK" << endl;
					cmd->lastOperation = now;//store the last Node into cmd
					cmdList.push_back(cmd);

					now = temp;//change current directory to what save in temp
				}
				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())
				{
					Command* lastcmd = cmdList.back();
					cmdList.pop_back();
					if (lastcmd->type == 0)//mkdir
					{
						Node* returnnode = now->rm(lastcmd->arg);
						if (returnnode != NULL)
						{
							success = true;
							break;
						}
					}
					else if (lastcmd->type == 1)//rm
					{
						success = now->addChild(lastcmd->lastOperation);
						break;
					}
					else if (lastcmd->type == 2)//cd
					{
						now = lastcmd->lastOperation;
						success = true;
						break;
					}
				}
				if (success) cout << "OK" << endl;
				else cout << "ERR" << endl;
			}
			}
		}
	}

	return 0;
}