feat: add solutions to lc problem: No.1233

No.1233.Remove Sub-Folders from the Filesystem

Author: yanglbme

solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README.md

@@ -56,110 +56,245 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：排序 + 前缀树**
+**方法一：排序**
+
+我们先将数组 `folder` 按照字典序排序，然后遍历数组，对于当前遍历到的文件夹 $f$，如果它的长度大于等于答案数组中最后一个文件夹的长度，并且它的前缀包含答案数组的最后一个文件夹再加上一个 `/`，则说明 $f$ 是答案数组中最后一个文件夹的子文件夹，我们不需要将其加入答案数组中。否则，我们将 $f$ 加入答案数组中。
+
+遍历结束后，答案数组中的文件夹即为题目要求的答案。
+
+时间复杂度 $O(n \times \log n \times m)$，空间复杂度 $O(m)$。其中 $n$ 和 $m$ 分别为数组 `folder` 的长度和数组 `folder` 中字符串的最大长度。
+
+**方法二：字典树**
+
+我们可以使用字典树存储数组 `folder` 中的所有文件夹。字典树的每个节点包含 `children` 字段，用于存储当前节点的子节点，以及 `fid` 字段，用于存储当前节点对应的文件夹在数组 `folder` 中的下标。
+
+对于数组 `folder` 中的每个文件夹 $f$，我们先将 $f$ 按照 `/` 分割成若干个子串，然后从根节点开始，依次将子串加入字典树中。接下来，我们从根节点开始搜索字典树，如果当前节点的 `fid` 字段不为 `-1`，则说明当前节点对应的文件夹是答案数组中的一个文件夹，我们将其加入答案数组并且返回。否则，我们递归地搜索当前节点的所有子节点，最终返回答案数组。
+
+时间复杂度 $O(n \times m)$，空间复杂度 $O(n \times m)$。其中 $n$ 和 $m$ 分别为数组 `folder` 的长度和数组 `folder` 中字符串的最大长度。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def removeSubfolders(self, folder: List[str]) -> List[str]:
+        folder.sort()
+        ans = [folder[0]]
+        for f in folder[1:]:
+            m, n = len(ans[-1]), len(f)
+            if m >= n or not (ans[-1] == f[:m] and f[m] == '/'):
+                ans.append(f)
+        return ans
+```
+
 ```python
 class Trie:
     def __init__(self):
         self.children = {}
-        self.is_end = False
+        self.fid = -1
 
-    def insert(self, w):
+    def insert(self, i, f):
         node = self
-        ps = w.split('/')
+        ps = f.split('/')
         for p in ps[1:]:
             if p not in node.children:
                 node.children[p] = Trie()
             node = node.children[p]
-        node.is_end = True
+        node.fid = i
 
-    def search(self, w):
-        node = self
-        ps = w.split('/')
-        for p in ps[1:]:
-            if p not in node.children:
-                return False
-            node = node.children[p]
-            if node.is_end:
-                return True
-        return False
+    def search(self):
+        def dfs(root):
+            if root.fid != -1:
+                ans.append(root.fid)
+                return
+            for child in root.children.values():
+                dfs(child)
 
+        ans = []
+        dfs(self)
+        return ans
 
 class Solution:
     def removeSubfolders(self, folder: List[str]) -> List[str]:
         trie = Trie()
-        folder.sort(key=lambda x: len(x.split('/')))
-        ans = []
-        for v in folder:
-            if not trie.search(v):
-                trie.insert(v)
-                ans.append(v)
-        return ans
+        for i, f in enumerate(folder):
+            trie.insert(i, f)
+        return [folder[i] for i in trie.search()]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    public List<String> removeSubfolders(String[] folder) {
+        Arrays.sort(folder);
+        List<String> ans = new ArrayList<>();
+        ans.add(folder[0]);
+        for (int i = 1; i < folder.length; ++i) {
+            int m = ans.get(ans.size() - 1).length();
+            int n = folder[i].length();
+            if (m >= n || !(ans.get(ans.size() - 1).equals(folder[i].substring(0, m)) && folder[i].charAt(m) == '/')) {
+                ans.add(folder[i]);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ```java
 class Trie {
-    Map<String, Trie> children = new HashMap<>();
-    boolean isEnd;
+    private Map<String, Trie> children = new HashMap<>();
+    private int fid = -1;
 
-    void insert(String w) {
+    public void insert(int fid, String f) {
         Trie node = this;
-        String[] ps = w.split("/");
+        String[] ps = f.split("/");
         for (int i = 1; i < ps.length; ++i) {
             String p = ps[i];
             if (!node.children.containsKey(p)) {
                 node.children.put(p, new Trie());
             }
             node = node.children.get(p);
         }
-        node.isEnd = true;
+        node.fid = fid;
     }
 
-    boolean search(String w) {
-        Trie node = this;
-        String[] ps = w.split("/");
-        for (int i = 1; i < ps.length; ++i) {
-            String p = ps[i];
-            if (!node.children.containsKey(p)) {
-                return false;
-            }
-            node = node.children.get(p);
-            if (node.isEnd) {
-                return true;
-            }
+    public List<Integer> search() {
+        List<Integer> ans = new ArrayList<>();
+        dfs(this, ans);
+        return ans;
+    }
+
+    private void dfs(Trie root, List<Integer> ans) {
+        if (root.fid != -1) {
+            ans.add(root.fid);
+            return;
+        }
+        for (var child : root.children.values()) {
+            dfs(child, ans);
         }
-        return false;
     }
 }
 
 class Solution {
     public List<String> removeSubfolders(String[] folder) {
-        Arrays.sort(folder, (a, b) -> a.split("/").length - b.split("/").length);
         Trie trie = new Trie();
+        for (int i = 0; i < folder.length; ++i) {
+            trie.insert(i, folder[i]);
+        }
         List<String> ans = new ArrayList<>();
-        for (String v : folder) {
-            if (!trie.search(v)) {
-                trie.insert(v);
-                ans.add(v);
-            }
+        for (int i : trie.search()) {
+            ans.add(folder[i]);
         }
         return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<string> removeSubfolders(vector<string>& folder) {
+        sort(folder.begin(), folder.end());
+        vector<string> ans = {folder[0]};
+        for (int i = 1; i < folder.size(); ++i) {
+            int m = ans.back().size();
+            int n = folder[i].size();
+            if (m >= n || !(ans.back() == folder[i].substr(0, m) && folder[i][m] == '/')) {
+                ans.emplace_back(folder[i]);
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Trie {
+public:
+    void insert(int fid, string& f) {
+        Trie* node = this;
+        vector<string> ps = split(f, '/');
+        for (int i = 1; i < ps.size(); ++i) {
+            auto& p = ps[i];
+            if (!node->children.count(p)) {
+                node->children[p] = new Trie();
+            }
+            node = node->children[p];
+        }
+        node->fid = fid;
+    }
+
+    vector<int> search() {
+        vector<int> ans;
+        function<void(Trie*)> dfs = [&](Trie* root) {
+            if (root->fid != -1) {
+                ans.push_back(root->fid);
+                return;
+            }
+            for (auto& [_, child] : root->children) {
+                dfs(child);
+            }
+        };
+        dfs(this);
+        return ans;
+    }
+
+    vector<string> split(string& s, char delim) {
+        stringstream ss(s);
+        string item;
+        vector<string> res;
+        while (getline(ss, item, delim)) {
+            res.emplace_back(item);
+        }
+        return res;
+    }
+
+private:
+    unordered_map<string, Trie*> children;
+    int fid = -1;
+};
+
+class Solution {
+public:
+    vector<string> removeSubfolders(vector<string>& folder) {
+        Trie* trie = new Trie();
+        for (int i = 0; i < folder.size(); ++i) {
+            trie->insert(i, folder[i]);
+        }
+        vector<string> ans;
+        for (int i : trie->search()) {
+            ans.emplace_back(folder[i]);
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
+```go
+func removeSubfolders(folder []string) []string {
+	sort.Strings(folder)
+	ans := []string{folder[0]}
+	for _, f := range folder[1:] {
+		m, n := len(ans[len(ans)-1]), len(f)
+		if m >= n || !(ans[len(ans)-1] == f[:m] && f[m] == '/') {
+			ans = append(ans, f)
+		}
+	}
+	return ans
+}
+```
+
 ```go
 type Trie struct {
 	children map[string]*Trie