Welcome to Subscribe On Youtube

1233. Remove Sub-Folders from the Filesystem

Description

Given a list of folders folder, return the folders after removing all sub-folders in those folders. You may return the answer in any order.

If a folder[i] is located within another folder[j], it is called a sub-folder of it.

The format of a path is one or more concatenated strings of the form: '/' followed by one or more lowercase English letters.

• For example, "/leetcode" and "/leetcode/problems" are valid paths while an empty string and "/" are not.

 

Example 1:

Input: folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
Output: ["/a","/c/d","/c/f"]
Explanation: Folders "/a/b" is a subfolder of "/a" and "/c/d/e" is inside of folder "/c/d" in our filesystem.

Example 2:

Input: folder = ["/a","/a/b/c","/a/b/d"]
Output: ["/a"]
Explanation: Folders "/a/b/c" and "/a/b/d" will be removed because they are subfolders of "/a".

Example 3:

Input: folder = ["/a/b/c","/a/b/ca","/a/b/d"]
Output: ["/a/b/c","/a/b/ca","/a/b/d"]

 

Constraints:

• 1 <= folder.length <= 4 * 104
• 2 <= folder[i].length <= 100
• folder[i] contains only lowercase letters and '/'.
• folder[i] always starts with the character '/'.
• Each folder name is unique.

Solutions

Solution 1: Sorting

First, we sort the array folder in lexicographical order, then traverse the array. For the current folder $f$ we are traversing, if its length is greater than or equal to the length of the last folder in the answer array, and its prefix includes the last folder in the answer array plus a /, then $f$ is a subfolder of the last folder in the answer array, and we don’t need to add it to the answer array. Otherwise, we add $f$ to the answer array.

After the traversal ends, the folders in the answer array are the answer required by the problem.

The time complexity is $O(n \times \log n \times m)$, and the space complexity is $O(m)$. Where $n$ and $m$ are the length of the array folder and the maximum length of the strings in the array folder, respectively.

Solution 2: Trie

We can use a trie to store all the folders in the array folder. Each node of the trie contains a children field, used to store the child nodes of the current node, and a fid field, used to store the index of the folder corresponding to the current node in the array folder.

For each folder $f$ in the array folder, we first split $f$ into several substrings according to /, then start from the root node and add the substrings to the trie in turn. Next, we start from the root node to search the trie. If the fid field of the current node is not -1, it means that the folder corresponding to the current node is a folder in the answer array. We add it to the answer array and return. Otherwise, we recursively search all child nodes of the current node and finally return the answer array.

The time complexity is $O(n \times m)$, and the space complexity is $O(n \times m)$. Where $n$ and $m$ are the length of the array folder and the maximum length of the strings in the array folder, respectively.

• Java
• C++
• Python
• Go
• TypeScript
• Javascript

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

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

• 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
  
  

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

• function removeSubfolders(folder: string[]): string[] {
      let s = folder[1];
      return folder.sort().filter(x => !x.startsWith(s + '/') && (s = x));
  }
  
  

• function removeSubfolders(folder) {
      let s = folder[1];
      return folder.sort().filter(x => !x.startsWith(s + '/') && (s = x));
  }
  
  

All Problems

All Solutions