【LeetCode】1233. 删除子文件夹

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⁴
• 2 <= folder[i].length <= 100
• folder[i] 只包含小写字母和 ‘/’
• folder[i] 总是以字符 ‘/’ 起始
• 每个文件夹名都是 唯一 的

---

算法一：排序

思路

• 先将数组 folder 按照字典序排序，然后遍历数组，对于当前遍历到的文件夹 f ，如果它的长度大于等于答案数组中最后一个文件夹的长度，并且它的前缀包含答案数组的最后一个文件夹再加上 / ，则说明 f 是答案数组中最后一个文件夹的子文件夹，我们不需要将其加入答案数组中，否则，将 f 加入答案数组。
• 遍历结束后， 答案数组中的文件夹即为题目要求的答案。

收获

• 我有想到排序，使得 folder 里的文件夹按照字典序排序。
• 对于子文件夹的判断，我是想用 c++ 的 strstr 函数，它能够判断 str1 是否是 str2 的子串，但是不知道为什么这个函数没办法成功；
• 题解用了 if 语句判断当前文件夹是否是子文件夹。

算法情况

• 时间复杂度：O（n* log n * m）；
• 空间复杂度：O（m），其中 n 和 m 分别是数组 folder 的长度 和 数组 folder 中字符串的最大长度。

代码

class Solution {
public:
    vector<string> removeSubfolders(vector<string>& folder) {
        sort(folder.begin(), folder.end());
        int n = folder.size();
        
        vector<string> ans = {folder[0]};
        for(int i=1; i<n; ++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;
    }
};

---

算法二：字典树 + stringstrem分割

思路

• 使用字典树存储数组 folder 中的所有文件夹，字典树的每个节点包含 children 字段，用于存储当前节点的子节点，以及 fid 字段，用于存储当前节点对应的文件夹在数组 folder 中的下标。
• 对于数组 folder 中的每个文件夹 f ，我们先将 f 按照 / 分割成若干个子串， 然后从根节点开始， 依次将子串加入字典树中。接下来， 我们从根节点开始搜索字典树， 如果当前节点的 fid 字段不为 -1， 则说明当前节点对应的文件夹是答案数组中的一个文件夹，我们将其加入答案数组并返回。 否则，我们递归地搜索当前节点的所有子节点，最终返回答案数组。

收获

• 当遇到 fid != -1 的节点就可以停止回溯了。

算法情况

• 时间复杂度：O（n * m）
• 空间复杂度：O（n * m），其中 n 和 m 分别是数组 folder 的长度 和 数组 folder 中字符串的最大长度。

代码

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;
    }
};

参考资料：

1. stringstream用法
   

2. getline()函数详解

3. 优秀题解

4. 字典树详解