【字典树（前缀树) 哈希映射 后序序列化】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

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

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

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。