Sync LeetCode submission Runtime - 174 ms (64.04%), Memory - 48.8 MB (67.42%)

Author: jimit105

2079-delete-duplicate-folders-in-system/README.md

@@ -0,0 +1,71 @@
+<p>Due to a bug, there are many duplicate folders in a file system. You are given a 2D array <code>paths</code>, where <code>paths[i]</code> is an array representing an absolute path to the <code>i<sup>th</sup></code> folder in the file system.</p>
+
+<ul>
+	<li>For example, <code>[&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]</code> represents the path <code>&quot;/one/two/three&quot;</code>.</li>
+</ul>
+
+<p>Two folders (not necessarily on the same level) are <strong>identical</strong> if they contain the <strong>same non-empty</strong> set of identical subfolders and underlying subfolder structure. The folders <strong>do not</strong> need to be at the root level to be identical. If two or more folders are <strong>identical</strong>, then <strong>mark</strong> the folders as well as all their subfolders.</p>
+
+<ul>
+	<li>For example, folders <code>&quot;/a&quot;</code> and <code>&quot;/b&quot;</code> in the file structure below are identical. They (as well as their subfolders) should <strong>all</strong> be marked:
+
+	<ul>
+		<li><code>/a</code></li>
+		<li><code>/a/x</code></li>
+		<li><code>/a/x/y</code></li>
+		<li><code>/a/z</code></li>
+		<li><code>/b</code></li>
+		<li><code>/b/x</code></li>
+		<li><code>/b/x/y</code></li>
+		<li><code>/b/z</code></li>
+	</ul>
+	</li>
+	<li>However, if the file structure also included the path <code>&quot;/b/w&quot;</code>, then the folders <code>&quot;/a&quot;</code> and <code>&quot;/b&quot;</code> would not be identical. Note that <code>&quot;/a/x&quot;</code> and <code>&quot;/b/x&quot;</code> would still be considered identical even with the added folder.</li>
+</ul>
+
+<p>Once all the identical folders and their subfolders have been marked, the file system will <strong>delete</strong> all of them. The file system only runs the deletion once, so any folders that become identical after the initial deletion are not deleted.</p>
+
+<p>Return <em>the 2D array </em><code>ans</code> <em>containing the paths of the <strong>remaining</strong> folders after deleting all the marked folders. The paths may be returned in <strong>any</strong> order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/19/lc-dupfolder1.jpg" style="width: 200px; height: 218px;" />
+<pre>
+<strong>Input:</strong> paths = [[&quot;a&quot;],[&quot;c&quot;],[&quot;d&quot;],[&quot;a&quot;,&quot;b&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;d&quot;,&quot;a&quot;]]
+<strong>Output:</strong> [[&quot;d&quot;],[&quot;d&quot;,&quot;a&quot;]]
+<strong>Explanation:</strong> The file structure is as shown.
+Folders &quot;/a&quot; and &quot;/c&quot; (and their subfolders) are marked for deletion because they both contain an empty
+folder named &quot;b&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/19/lc-dupfolder2.jpg" style="width: 200px; height: 355px;" />
+<pre>
+<strong>Input:</strong> paths = [[&quot;a&quot;],[&quot;c&quot;],[&quot;a&quot;,&quot;b&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;a&quot;,&quot;b&quot;,&quot;x&quot;],[&quot;a&quot;,&quot;b&quot;,&quot;x&quot;,&quot;y&quot;],[&quot;w&quot;],[&quot;w&quot;,&quot;y&quot;]]
+<strong>Output:</strong> [[&quot;c&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;a&quot;],[&quot;a&quot;,&quot;b&quot;]]
+<strong>Explanation: </strong>The file structure is as shown. 
+Folders &quot;/a/b/x&quot; and &quot;/w&quot; (and their subfolders) are marked for deletion because they both contain an empty folder named &quot;y&quot;.
+Note that folders &quot;/a&quot; and &quot;/c&quot; are identical after the deletion, but they are not deleted because they were not marked beforehand.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/19/lc-dupfolder3.jpg" style="width: 200px; height: 201px;" />
+<pre>
+<strong>Input:</strong> paths = [[&quot;a&quot;,&quot;b&quot;],[&quot;c&quot;,&quot;d&quot;],[&quot;c&quot;],[&quot;a&quot;]]
+<strong>Output:</strong> [[&quot;c&quot;],[&quot;c&quot;,&quot;d&quot;],[&quot;a&quot;],[&quot;a&quot;,&quot;b&quot;]]
+<strong>Explanation:</strong> All folders are unique in the file system.
+Note that the returned array can be in a different order as the order does not matter.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= paths.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= paths[i].length &lt;= 500</code></li>
+	<li><code>1 &lt;= paths[i][j].length &lt;= 10</code></li>
+	<li><code>1 &lt;= sum(paths[i][j].length) &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>path[i][j]</code> consists of lowercase English letters.</li>
+	<li>No two paths lead to the same folder.</li>
+	<li>For any folder not at the root level, its parent folder will also be in the input.</li>
+</ul>

2079-delete-duplicate-folders-in-system/solution.py

@@ -0,0 +1,64 @@
+class Trie:
+    # current node structure's serialized representation
+    serial: str = ""
+    # current node's child nodes
+    children: dict
+
+    def __init__(self):
+        self.children = dict()
+
+
+class Solution:
+    def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+        # root node
+        root = Trie()
+
+        for path in paths:
+            cur = root
+            for node in path:
+                if node not in cur.children:
+                    cur.children[node] = Trie()
+                cur = cur.children[node]
+
+        # hash table records the occurrence times of each serialized representation
+        freq = Counter()
+
+        # post-order traversal based on depth-first search, calculate the serialized representation of each node structure
+        def construct(node: Trie) -> None:
+            # if it is a leaf node, then the serialization is represented as an empty string, and no operation is required.
+            if not node.children:
+                return
+
+            v = list()
+            # if it is not a leaf node, the serialization representation of the child node structure needs to be calculated first.
+            for folder, child in node.children.items():
+                construct(child)
+                v.append(folder + "(" + child.serial + ")")
+
+            # to prevent issues with order, sorting is needed
+            v.sort()
+            node.serial = "".join(v)
+            # add to hash table
+            freq[node.serial] += 1
+
+        construct(root)
+
+        ans = list()
+        # record the path from the root node to the current node.
+        path = list()
+
+        def operate(node: Trie) -> None:
+            # if the serialization appears more than once in the hash table, it needs to be deleted.
+            if freq[node.serial] > 1:
+                return
+            # otherwise add the path to the answer
+            if path:
+                ans.append(path[:])
+
+            for folder, child in node.children.items():
+                path.append(folder)
+                operate(child)
+                path.pop()
+
+        operate(root)
+        return ans