【LeetCode每日一题】【2023/2/8】1233. 删除子文件夹

---

1233. 删除子文件夹

LeetCode: 1233. 删除子文件夹

$中等$

你是一位系统管理员，手里有一份文件夹列表 folder，你的任务是要删除该列表中的所有 子文件夹，并以 任意顺序 返回剩下的文件夹。

如果文件夹 folder[i] 位于另一个文件夹 folder[j] 下，那么 folder[i] 就是 folder[j] 的 子文件夹 。

文件夹的「路径」是由一个或多个按以下格式串联形成的字符串：'/' 后跟一个或者多个小写英文字母。

• 例如，"/leetcode" 和 "/leetcode/problems" 都是有效的路径，而空字符串和 "/" 不是。

示例 1：

输入：folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
输出：["/a","/c/d","/c/f"]
解释："/a/b/" 是 "/a" 的子文件夹，而 "/c/d/e" 是 "/c/d" 的子文件夹。

示例 2：

输入：folder = ["/a","/a/b/c","/a/b/d"]
输出：["/a"]
解释：文件夹 "/a/b/c" 和 "/a/b/d/" 都会被删除，因为它们都是 "/a" 的子文件夹。

示例 3：

输入: folder = ["/a/b/c","/a/b/ca","/a/b/d"]
输出: ["/a/b/c","/a/b/ca","/a/b/d"]

提示：

• 1 <= folder.length <= 4 * 10^4
• 2 <= folder[i].length <= 100
• folder[i] 只包含小写字母和 '/'
• folder[i] 总是以字符 '/' 起始
• 每个文件夹名都是 唯一 的

---

方法1：字典树

字典树中，每个结点存放一个字符。从根结点出发到某一节点，路径上所有的字符链接起来便能组成一个英文单词。该 “某一结点” 需要一个布尔值来表示：遍历到这个结点时是否能够组成一个 单词 ，或可以成为一次遍历的 终点 。若不能则继续往下遍历；若能组成单词，且当前结点还有孩子结点，则代表当前单词会作为其它单词的 前缀 出现：例如 “move” 是 “movement” 的前缀，“move” 中的结点 “e” 可以作为 一次遍历 的终点，也可以选择继续遍历，以 “movement” 中的结点 “t” 作为终点。

对于本题，也可以采用字典树的方式解决。将每一个 '/' 之间的 文件夹名 字符串作为每个结点 TrieNode 的值。例如 “/a/b/ca” 所构造出的字典树为 {a}->{b}->{ca} 。其中，结点 {ca} 处需要标示其为一个 终点 。

字典树结点

在结点 TrieNode 的定义中考虑怎么存放值时，可以使用 std::string_view 来避免字符串的重复构造。其只含有两个成员变量：字符串的起始位置和字符串长度。

字典树中 孩子结点 的存放需要 哈希表 来完成。以 结点的值 为 哈希表的键 ，本题中即为 被 '/' 分割的文件夹名；以 TrieNode* 类型的指针作为 哈希表的值 。这样就建立了从 文件夹名 到 该文件夹所对应的结点 的映射关系。最终类型为 std::unordered_map<std::string_view, TrieNode*>

最后是如何标示某个结点是否会是 一次遍历 的 终点 。我们可以从题目的要求出发去考虑。题目要求删去所有 子文件夹 ，而 子文件夹 均存在一个 前缀 。这就意味着我们需要对字典树进行 深度遍历 。当从根结点出发按照 任一路径 遍历结点时，只要在当前路径上找到了一个 终点 ，那么就需要将该路径完整地记录下来。而该 完整路径 正好会是数组 folder 中的一个元素：

例如 folder 中仅有一个元素 “/a/b/ca” ，其所构造出的字典树为 {a}->{b}->{ca} 。遍历时，不会以 “b” 为终点，因为 folder 中没有元素 “a/b” ；遍历时，会以 “ca” 为终点，此时 folder 中存放了 完整的路径 “/a/b/ca” 。

于是可以用该 终点结点 所对应的 路径字符串 在 folder 中的 索引 来标记该结点为终点结点，如上述中 “ca” 结点对应 “/a/b/ca” 在 folder 中的索引为 0 ，因此 “ca” 结点中记录 0 。若不是终点结点，则该索引记为 -1 ，如上述中 “a” 结点和 “b” 结点的索引即为 -1 ，代表它们不会是一次遍历的终点。

TrieNode 的定义如下：

struct TrieNode
{
	int index;
	unordered_map<string_view, TrieNode*> children;

	explicit TrieNode(const int index = -1)
		: index{index} {}
};

以 ‘/’ 分割路径

本题所需要构造的字典树中，以每个 '/' 分割出来的 文件夹名 作为字典树结点的值。因此我们要对 folder[i] 进行分割。

由于所有路径均存放于 folder 中，在整个算法过程中均为左值，因此这里可以在数组 std::vector 中存放 std::string_view 来避免字符串的重复构造。

static vector<string_view> SplitPath(const string& path)
{
	vector<string_view> folderNames;
	for (int begin = 1; begin < path.length();)
	{
		if (const int end = path.find_first_of('/', begin);
			end != std::string::npos)
		{
			folderNames.emplace_back(path.data() + begin, end - begin);
			begin = end + 1;
		}
		else
		{
			folderNames.emplace_back(path.data() + begin, path.length() - begin);
			break;
		}
	}
	return folderNames;
}

构造字典树

定义函数 CreateTrie ，传入整个路径数组 folder 。循环遍历 folder ，对每个 folder[i] 构造结点。

剪枝优化：我们只需要 非 子文件夹 。假设 folder 中存有 “/a/b” 和 “/a/b/c” ，我们最终的答案中需要排除 “/a/b/c” 。在之后遍历寻找终点时，找到了 “/a/b” 便是答案，其之后的路径都不会访问，因此我们在构造字典树时甚至都不需要 构造 “/a/b/c”。

于是，我们首先构造出了 “{a}->{b}” 。之后处理 “/a/b/c” 时，首先从根节点出发到达 “a” 结点，再从 “a” 结点出发到达 “b” 结点。此时发现 “b” 结点存放的 索引 值为 0 ，是一个终点。因此本次处理 “/a/b/c” 的流程直接跳过即可。

若我们先处理了 “/a/b/c” 再处理 “/a/b” ，也就是说 folder 中存放它们的顺序不同，那么 “/a/b/c” 还是会被完整构造。

TrieNode* CreateTrie(const vector<string>& folder)
{
	TrieNode* head = new TrieNode{};
	for (int i = 0; i < folder.size(); ++i)
	{
		vector<string_view> folderNames = SplitPath(folder[i]);
		TrieNode* node = head;

		for (const string_view& folderName : folderNames)
		{
			if (auto it = node->children.find(folderName);
				it != node->children.end())
			{
				node = it->second;

				if (node->index != -1)
					break;
			}
			else
			{
				TrieNode* temp = new TrieNode{};
				node->children.emplace(folderName, temp);
				node = temp;
			}
		}

		if (node->index == -1)
			node->index = i;
	}
	return head;
}

完成算法

遍历字典树即可。这里采用了迭代的方式。使用递归方式也可。

vector<string> removeSubfolders(const vector<string>& folder)
{
	TrieNode* head = CreateTrie(folder);

	vector<string> ans;
	stack<const TrieNode*> stk;
	stk.emplace(head);

	while (!stk.empty())
	{
		const TrieNode* node = stk.top();
		stk.pop();

		if (node->index != -1)
		{
			ans.emplace_back(folder[node->index]);
		}
		else
		{
			for (const auto& [_, child] : node->children)
				stk.emplace(child);
		}
	}

	return ans;
}

代码总体

#include <vector>
#include <string>
#include <unordered_map>
#include <stack>
using namespace std;

class Solution
{
private:
	struct TrieNode;

public:
	vector<string> removeSubfolders(const vector<string>& folder)
	{
		TrieNode* head = CreateTrie(folder);

		vector<string> ans;
		stack<const TrieNode*> stk;
		stk.emplace(head);

		while (!stk.empty())
		{
			const TrieNode* node = stk.top();
			stk.pop();

			if (node->index != -1)
			{
				ans.emplace_back(folder[node->index]);
			}
			else
			{
				for (const auto& [_, child] : node->children)
					stk.emplace(child);
			}
		}

		return ans;
	}

	static vector<string_view> SplitPath(const string& path)
	{
		vector<string_view> folderNames;
		for (int begin = 1; begin < path.length();)
		{
			if (const int end = path.find_first_of('/', begin);
				end != std::string::npos)
			{
				folderNames.emplace_back(path.data() + begin, end - begin);
				begin = end + 1;
			}
			else
			{
				folderNames.emplace_back(path.data() + begin, path.length() - begin);
				break;
			}
		}
		return folderNames;
	}

	TrieNode* CreateTrie(const vector<string>& folder)
	{
		TrieNode* head = new TrieNode{};
		for (int i = 0; i < folder.size(); ++i)
		{
			vector<string_view> folderNames = SplitPath(folder[i]);
			TrieNode* node = head;

			for (const string_view& folderName : folderNames)
			{
				if (auto it = node->children.find(folderName);
					it != node->children.end())
				{
					node = it->second;

					if (node->index != -1)
						break;
				}
				else
				{
					TrieNode* temp = new TrieNode{};
					node->children.emplace(folderName, temp);
					node = temp;
				}
			}

			if (node->index == -1)
				node->index = i;
		}
		return head;
	}

private:
	struct TrieNode
	{
		int index;
		unordered_map<string_view, TrieNode*> children;

		explicit TrieNode(const int index = -1)
			: index{index} {}
	};
};

复杂度分析：

• 时间复杂度：$O(n\times \overline{L})$。其中，$n$ 为数组 folder 的长度，$\overline{L}$ 为 folder 中文件夹名的平均长度。

• 空间复杂度：$O(n\times \overline{L})$。主要为字典树的开销。

参考结果

Accepted
32/32 cases passed (208 ms)
Your runtime beats 29.23 % of cpp submissions
Your memory usage beats 20.77 % of cpp submissions (89.8 MB)