【字典树（前缀树) 哈希映射后序序列化】1948. 删除系统中的重复文件夹

本文涉及知识点

字典树（前缀树) 哈希映射后序序列化

LeetCode 1948. 删除系统中的重复文件夹

由于一个漏洞，文件系统中存在许多重复文件夹。给你一个二维数组 paths，其中 paths[i] 是一个表示文件系统中第 i 个文件夹的绝对路径的数组。
例如，[“one”, “two”, “three”] 表示路径 “/one/two/three” 。
如果两个文件夹（不需要在同一层级）包含非空且相同的子文件夹集合并具有相同的子文件夹结构，则认为这两个文件夹是相同文件夹。相同文件夹的根层级不需要相同。如果存在两个（或两个以上）相同文件夹，则需要将这些文件夹和所有它们的子文件夹标记为待删除。

例如，下面文件结构中的文件夹 “/a” 和 “/b” 相同。它们（以及它们的子文件夹）应该被全部标记为待删除：
/a
/a/x
/a/x/y
/a/z
/b
/b/x
/b/x/y
/b/z
然而，如果文件结构中还包含路径 “/b/w” ，那么文件夹 “/a” 和 “/b” 就不相同。注意，即便添加了新的文件夹 “/b/w” ，仍然认为 “/a/x” 和 “/b/x” 相同。
一旦所有的相同文件夹和它们的子文件夹都被标记为待删除，文件系统将会删除所有上述文件夹。文件系统只会执行一次删除操作。执行完这一次删除操作后，不会删除新出现的相同文件夹。
返回二维数组 ans ，该数组包含删除所有标记文件夹之后剩余文件夹的路径。路径可以按任意顺序返回。
示例 1：
在这里插入图片描述

输入：paths = [[“a”],[“c”],[“d”],[“a”,“b”],[“c”,“b”],[“d”,“a”]]
输出：[[“d”],[“d”,“a”]]
解释：文件结构如上所示。
文件夹 “/a” 和 “/c”（以及它们的子文件夹）都会被标记为待删除，因为它们都包含名为 “b” 的空文件夹。
示例 2：

在这里插入图片描述

输入：paths = [[“a”],[“c”],[“a”,“b”],[“c”,“b”],[“a”,“b”,“x”],[“a”,“b”,“x”,“y”],[“w”],[“w”,“y”]]
输出：[[“c”],[“c”,“b”],[“a”],[“a”,“b”]]
解释：文件结构如上所示。
文件夹 “/a/b/x” 和 “/w”（以及它们的子文件夹）都会被标记为待删除，因为它们都包含名为 “y” 的空文件夹。
注意，文件夹 “/a” 和 “/c” 在删除后变为相同文件夹，但这两个文件夹不会被删除，因为删除只会进行一次，且它们没有在删除前被标记。
示例 3：
在这里插入图片描述

输入：paths = [[“a”,“b”],[“c”,“d”],[“c”],[“a”]]
输出：[[“c”],[“c”,“d”],[“a”],[“a”,“b”]]
解释：文件系统中所有文件夹互不相同。
注意，返回的数组可以按不同顺序返回文件夹路径，因为题目对顺序没有要求。
示例 4：
在这里插入图片描述

输入：paths = [[“a”],[“a”,“x”],[“a”,“x”,“y”],[“a”,“z”],[“b”],[“b”,“x”],[“b”,“x”,“y”],[“b”,“z”]]
输出：[]
解释：文件结构如上所示。
文件夹 “/a/x” 和 “/b/x”（以及它们的子文件夹）都会被标记为待删除，因为它们都包含名为 “y” 的空文件夹。
文件夹 “/a” 和 “/b”（以及它们的子文件夹）都会被标记为待删除，因为它们都包含一个名为 “z” 的空文件夹以及上面提到的文件夹 “x” 。
示例 5：
在这里插入图片描述

输入：paths = [[“a”],[“a”,“x”],[“a”,“x”,“y”],[“a”,“z”],[“b”],[“b”,“x”],[“b”,“x”,“y”],[“b”,“z”],[“b”,“w”]]
输出：[[“b”],[“b”,“w”],[“b”,“z”],[“a”],[“a”,“z”]]
解释：本例与上例的结构基本相同，除了新增 “/b/w” 文件夹。
文件夹 “/a/x” 和 “/b/x” 仍然会被标记，但 “/a” 和 “/b” 不再被标记，因为 “/b” 中有名为 “w” 的空文件夹而 “/a” 没有。
注意，“/a/z” 和 “/b/z” 不会被标记，因为相同子文件夹的集合必须是非空集合，但这两个文件夹都是空的。

提示：

1 <= paths.length <= 2 * 10⁴
1 <= paths[i].length <= 500
1 <= paths[i][j].length <= 10
1 <= sum(paths[i][j].length) <= 2 * 10⁵
path[i][j] 由小写英文字母组成
不会存在两个路径都指向同一个文件夹的情况
对于不在根层级的任意文件夹，其父文件夹也会包含在输入中

字典树

如何判断两个文件夹是否相等？除子树根节点外的序列化是否相等。后序序列化更简单。序列化完子孙后就比较。
分三步：
一，将所有path放到字典树中。字典树的节点包括path[i][j]，i。
二，DFS字典树，将各路径不包括当前节点的后序序列化放到哈希映射m_mSer中，并记录数量。注意：序列时，要排序。不如：直接用有序映射。
三，DFS字典树，看各节点是否有相等的哈希，标记此节点需要删除。
四，复制不需要删除的节点到vRet中。

复杂度

主要复杂度在序列化。
令 $\forall i\forall j$ path[i][i]的层次是leve(从0开始），则它序列化leve+1次，它会被它及它的祖先序列化。
它及它的祖先分别被序列化： leve+1 ,leve $\cdots$ 1 次
它及它的祖先分别在path出现的次数： 1 ,2 $\cdots$ leve+1 次。
次数相同，等于 path[i][j] 元素的个数，我们假设最极端情况下： $\forall i\forall j$ path[i][j].length==1。令o=sum(path[i][j].lenght()) ，则 $\sum$ path[i][j]序列的次数 <= o。再次假设极端情况下： $\forall i\forall j$ path[i][j] == 10。则序列化的空间复制度和时间复杂度等于O(o $\times$ 10) $\approx$ 2 $\times$ 10⁶

代码

核心代码

class CStrToIndex
{
public:CStrToIndex() {}CStrToIndex(const vector<string>& wordList) {for (const auto& str : wordList){Add(str);}}int Add(const string& str){if (m_mIndexs.count(str)) { return m_mIndexs[str]; }m_mIndexs[str] = m_strs.size();m_strs.push_back(str);return  m_strs.size()-1;}vector<string> m_strs;int GetIndex(const string& str){if (m_mIndexs.count(str)) { return m_mIndexs[str]; }return -1;}
protected:unordered_map<string, int> m_mIndexs;
};class CPathTrieNode
{
public:CPathTrieNode* Add(string str) {if (!m_mChild.count(str)) {m_mChild[str] = new CPathTrieNode();}return m_mChild[str];}int m_iSerIndex =-1;map<string, CPathTrieNode*> m_mChild;
};class CPathTrie {
public:void Add(const vector<string>& path) {auto ptr = &m_root;for (auto& s : path) {ptr = ptr->Add(s);}}CPathTrieNode m_root;
};
class Solution {
public:vector<vector<string>> deleteDuplicateFolder(vector<vector<string>>& paths) {CPathTrie trie;for (const auto& path : paths) {trie.Add(path);}DFSForSer("", &trie.m_root);vector<string> stack;DFS(stack, &trie.m_root);return m_vRet;}string DFSForSer (string strName,CPathTrieNode* cur) {string str;for (const auto& [tmp, child] : cur->m_mChild) {str += "(" + DFSForSer(tmp,child) + ")";}if ("" != str)	{cur->m_iSerIndex = m_strIndex.Add(str);	m_mIndexCount[cur->m_iSerIndex]++;}str += strName;return str ;};void DFS(vector<string>& stack, CPathTrieNode* cur){for (const auto& [tmp, child] : cur->m_mChild) {if ((-1 != child->m_iSerIndex) && (m_mIndexCount[child->m_iSerIndex] > 1)) {continue;}stack.emplace_back(tmp);m_vRet.emplace_back(stack);DFS(stack, child);stack.pop_back();}}vector<vector<string>> m_vRet;unordered_map<int, int> m_mIndexCount;CStrToIndex m_strIndex;
};

VS自带的单元测试

template<class T1,class T2>
void AssertEx(const T1& t1, const T2& t2)
{Assert::AreEqual(t1 , t2);
}template<class T>
void AssertEx(const vector<T>& v1, const vector<T>& v2)
{Assert::AreEqual(v1.size(), v2.size());	for (int i = 0; i < v1.size(); i++){Assert::AreEqual(v1[i], v2[i]);}
}template<class T>
void AssertV2(vector<vector<T>> vv1, vector<vector<T>> vv2)
{sort(vv1.begin(), vv1.end());sort(vv2.begin(), vv2.end());Assert::AreEqual(vv1.size(), vv2.size());for (int i = 0; i < vv1.size(); i++){AssertEx(vv1[i], vv2[i]);}
}namespace UnitTest
{vector<vector<string>> paths;TEST_CLASS(UnitTest){public:TEST_METHOD(TestMethod1){paths = { {"a"},{"c"},{"d"},{"a","b"},{"c","b"},{"d","a"} };auto res = Solution().deleteDuplicateFolder(paths);			AssertV2(res,{ {"d"},{"d","a"} });}TEST_METHOD(TestMethod2){paths = { {"a"},{"c"},{"a","b"},{"c","b"},{"a","b","x"},{"a","b","x","y"},{"w"},{"w","y"} };auto res = Solution().deleteDuplicateFolder(paths);AssertV2(res, { {"c"},{"c","b"},{"a"},{"a","b"} });}TEST_METHOD(TestMethod3){paths = { {"a","b"},{"c","d"},{"c"},{"a"} };auto res = Solution().deleteDuplicateFolder(paths);AssertV2(res, { {"c"},{"c","d"},{"a"},{"a","b"} });}TEST_METHOD(TestMethod4){paths = { {"a"},{"a","x"},{"a","x","y"},{"a","z"},{"b"},{"b","x"},{"b","x","y"},{"b","z"} };auto res = Solution().deleteDuplicateFolder(paths);AssertV2(res, {  });}TEST_METHOD(TestMethod5){paths = { {"a"},{"a","x"},{"a","x","y"},{"a","z"},{"b"},{"b","x"},{"b","x","y"},{"b","z"},{"b","w"} };auto res = Solution().deleteDuplicateFolder(paths);AssertV2(res, { {"b"},{"b","w"},{"b","z"},{"a"},{"a","z"} });}};
}

扩展阅读

视频课程

有效学习：明确的目标及时的反馈拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛