[LeetCode] Longest Absolute File Path 最長的絕對文件路徑

 

Suppose we abstract our file system by a string in the following manner:

The string "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext" represents:

dir
    subdir1
    subdir2
        file.ext

The directory dir contains an empty sub-directory subdir1 and a sub-directory subdir2 containing a file file.ext.

The string "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext" represents:

dir
    subdir1
        file1.ext
        subsubdir1
    subdir2
        subsubdir2
            file2.ext

The directory dir contains two sub-directories subdir1 and subdir2. subdir1 contains a file file1.ext and an empty second-level sub-directorysubsubdir1. subdir2 contains a second-level sub-directory subsubdir2 containing a file file2.ext.

We are interested in finding the longest (number of characters) absolute path to a file within our file system. For example, in the second example above, the longest absolute path is "dir/subdir2/subsubdir2/file2.ext", and its length is 32 (not including the double quotes).

Given a string representing the file system in the above format, return the length of the longest absolute path to file in the abstracted file system. If there is no file in the system, return 0.

Note:

• The name of a file contains at least a . and an extension.
• The name of a directory or sub-directory will not contain a ..

 

Time complexity required: O(n) where n is the size of the input string.

Notice that a/aa/aaa/file1.txt is not the longest file path, if there is another path aaaaaaaaaaaaaaaaaaaaa/sth.png.

 

這道題給了咱們一個字符串，裏面包含 \n 和 \t 這種表示回車和空格的特殊字符，讓咱們找到某一個最長的絕對文件路徑，要注意的是，最長絕對文件路徑不必定是要最深的路徑，咱們能夠用 HashMap 來創建深度和當前深度的絕對路徑長度之間的映射，那麼當前深度下的文件的絕對路徑就是文件名長度加上 HashMap 中當前深度對應的長度，咱們的思路是遍歷整個字符串，遇到 \n 或者 \t 就停下來，而後咱們判斷，若是遇到的是回車，咱們把這段文件名提取出來，若是裏面包含 '.'，說明是文件，咱們更新 res 長度，若是不包含點，說明是文件夾，咱們深度 level 自增1，而後創建當前深度和總長度之間的映射，而後咱們將深度 level 重置爲0。以前若是遇到的是空格 \t，那麼咱們深度加一，經過累加 \t 的個數，咱們能夠得知當前文件或文件夾的深度，而後作對應的處理，參見代碼以下：

 

C++ 解法一：

class Solution {
public:
    int lengthLongestPath(string input) {
        int res = 0, n = input.size(), level = 0;
        unordered_map<int, int> m {{0, 0}};
        for (int i = 0; i < n; ++i) {
            int start = i;
            while (i < n && input[i] != '\n' && input[i] != '\t') ++i;
            if (i >= n || input[i] == '\n') {
                string t = input.substr(start, i - start);
                if (t.find('.') != string::npos) {
                    res = max(res, m[level] + (int)t.size());
                } else {
                    ++level;
                    m[level] = m[level - 1] + (int)t.size() + 1;
                }
                level = 0;
            } else {
                ++level;
            }
        }
        return res;
    }
};

 

下面這種方法用到了字符串流機制，經過 getline() 函數能夠一行一行的獲取數據，實際上至關於根據回車符 \n 把每段分割開了，而後對於每一行，咱們找最後一個空格符 \t 的位置，而後能夠獲得文件或文件夾的名字，而後咱們判斷其是文件仍是文件夾，若是是文件就更新 res，若是是文件夾就更新 HashMap 的映射，參見代碼以下：

 

C++ 解法二：

class Solution {
public:
    int lengthLongestPath(string input) {
        int res = 0;
        istringstream ss(input);
        unordered_map<int, int> m{{0, 0}};
        string line = "";
        while (getline(ss, line)) {
            int level = line.find_last_of('\t') + 1;
            int len = line.substr(level).size();
            if (line.find('.') != string::npos) {
                res = max(res, m[level] + len);
            } else {
                m[level + 1] = m[level] + len + 1;
            }
        }
        return res;
    }
};

 

Java 解法二：

public class Solution {
    public int lengthLongestPath(String input) {
        int res = 0;
        Map<Integer, Integer> m = new HashMap<>();
        m.put(0, 0);
        for (String s : input.split("\n")) {
            int level = s.lastIndexOf("\t") + 1;
            int len = s.substring(level).length();
            if (s.contains(".")) {
                res = Math.max(res, m.get(level) + len);
            } else {
                m.put(level + 1, m.get(level) + len + 1);
            }
        }
        return res;
    }
}

 

參考資料：

https://leetcode.com/problems/longest-absolute-file-path/

https://leetcode.com/problems/longest-absolute-file-path/discuss/86615/9-lines-4ms-Java-solution

https://leetcode.com/problems/longest-absolute-file-path/discuss/86821/c-on-solution-with-hashmap

https://leetcode.com/problems/longest-absolute-file-path/discuss/86719/two-different-solutions-in-java-using-stack-and-hashmap

 

LeetCode All in One 題目講解彙總(持續更新中...)