[Swift]LeetCode388. 文件的最长绝对路径 | Longest Absolute File Path

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9778434.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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

The string "dir subdir1 subdir2 file.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 subdir1 file1.ext subsubdir1 subdir2 subsubdir2 file2.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-directory subsubdir1. subdir2 contains a second-level sub-directory subsubdir2containing 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.

---

 假设我们以下述方式将我们的文件系统抽象成一个字符串:

字符串 "dir subdir1 subdir2 file.ext" 表示:

dir
    subdir1
    subdir2
        file.ext

目录 dir 包含一个空的子目录 subdir1 和一个包含一个文件 file.ext 的子目录 subdir2 。

字符串 "dir subdir1 file1.ext subsubdir1 subdir2 subsubdir2 file2.ext" 表示:

dir
    subdir1
        file1.ext
        subsubdir1
    subdir2
        subsubdir2
            file2.ext

目录 dir 包含两个子目录 subdir1 和 subdir2。 subdir1 包含一个文件 file1.ext 和一个空的二级子目录 subsubdir1。subdir2 包含一个二级子目录 subsubdir2 ，其中包含一个文件 file2.ext。

我们致力于寻找我们文件系统中文件的最长 (按字符的数量统计) 绝对路径。例如，在上述的第二个例子中，最长路径为 "dir/subdir2/subsubdir2/file2.ext"，其长度为 32 (不包含双引号)。

给定一个以上述格式表示文件系统的字符串，返回文件系统中文件的最长绝对路径的长度。 如果系统中没有文件，返回 0。

说明:

• 文件名至少存在一个 . 和一个扩展名。
• 目录或者子目录的名字不能包含 .。

要求时间复杂度为 O(n) ，其中 n 是输入字符串的大小。

请注意，如果存在路径 aaaaaaaaaaaaaaaaaaaaa/sth.png 的话，那么  a/aa/aaa/file1.txt 就不是一个最长的路径。

---

 16ms

class Solution {
    func lengthLongestPath(_ input: String) -> Int {
        guard input != nil || input.count != 0 else
        {
            return 0
        }
        //创建整形堆栈，存放各级文件长度
        var stackOfLen = Stack<Int>()
        var strArray = input.characters.split{$0 == "
"}.map(String.init)
        var longesLen:Int = 0
        for i in 0..<strArray.count
        {
            let item:String = strArray[i]
            ////计算当前文件的层级
            var level = LastIndexOf(item)
            //返回到上一个同级文件的位置,注意使用count(),而非count
            //例如：示例中遇到 	subdir2 时返回到与它同级的 	subdir1 位置
            while(stackOfLen.count() > level)
            {
                stackOfLen.pop()
            }
            let tempLen:Int = item.count - level
            if stackOfLen.count() == 0
            {
                stackOfLen.push(tempLen)
            }
            else
            {
                ////加1 是返回的结果带有 / 分割
                let num:Int = tempLen + stackOfLen.GetLastElement() + 1
                stackOfLen.push(num)
            }
            if item.contains(".")
            {                
                longesLen = max(longesLen,stackOfLen.GetLastElement())
            }     
        }
        return  longesLen
    }
    //获取最后一个"	"的索引整数位置
    func LastIndexOf(_ item:String) -> Int
    {
        var num:Int = 0
        var itemReversed:ReversedCollection<String> = item.reversed()
        for i in 0..<itemReversed.count
        {
            var char:Character = itemReversed[itemReversed.index(itemReversed.startIndex, offsetBy: i)]
            if  char == "	"
            {
                //注意索引也要反转，返回的为索引位置+1
                num = item.count - i
                break
            }
        }
        return num
    }
        
    //堆栈的泛型通用版本
    struct Stack<Element> {
        var items = [Element]()
        //入栈
        //mutating 关键字修饰方法是为了能在该方法中修改 struct 或是 enum 的变量
        mutating func push(_ item: Element) {
            items.append(item)
        }
        //出栈
        mutating func pop() -> Element {
            return items.removeLast()
        }
        //返回堆栈中的元素个数
        mutating func count() -> Int
        {
            return items.count
        }
        //获取最后一个元素
        mutating func GetLastElement()->Element
        {
            return items[items.count-1]
        }
    }
}

---

8ms

class Solution {
    
    func lengthLongestPath(_ input: String) -> Int {
        guard !input.isEmpty else { return 0 }
        
        let lines = input.split(separator: "
").map{ String($0) }
        var sum = [Int](repeating: 0, count: input.count + 1)
        var result = 0
        
        for line in lines {
            var count = 0 
            while line.charAt(count) == "	" {
                count += 1
            }
            let level = count + 1
            let len = line.count - (level - 1)
            if line.contains(".") {
                result = max(result, sum[level - 1] + len + level - 1)
            } else {
                sum[level] = sum[level - 1] + len
            }
        }
        
        return result 
    }
}

extension String {
    
    func charAt(_ i: Int) -> Character {
        let index = self.index(self.startIndex, offsetBy: i)
        return self[index]
    }
}

---

12ms

class Solution {
    func lengthLongestPath(_ input: String) -> Int {
        var dirPathLengths = [Int]()
        var maxLength = 0
        for pathComponent in input.split(separator: "
") {
            var dirLength = 0
            let isFile = pathComponent.contains(".")
            for (depth, dirLevel) in pathComponent.split(separator: "	", omittingEmptySubsequences: false).enumerated() {
                let isPathComponentFile = dirLevel.contains(".")
                if depth < dirPathLengths.count {
                    if !dirLevel.isEmpty && !isFile {
                        dirPathLengths[depth] = dirLevel.count
                    }
                } else {
                    if !dirLevel.isEmpty && !isFile {
                        dirPathLengths.append(dirLevel.count)
                    }
                }
                if isFile {
                    dirLength += (isPathComponentFile ? pathComponent.count : dirPathLengths[depth])
                }
            }
            maxLength = max(maxLength, dirLength)
        }
        return maxLength
    }
}

---

16ms

class Solution {
    
    func lengthLongestPath(_ input: String) -> Int {
        guard !input.isEmpty else { return 0 }
        
        let lines = input.split(separator: "
").map{ String($0) }
        var sum = [Int](repeating: 0, count: input.count + 1)
        var result = 0
        
        for line in lines {
            var count = 0 
            while line.charAt(count) == "	" {
                count += 1
            }
            let level = count + 1
            let len = line.count - (level - 1)
            if line.contains(".") {
                result = max(result, sum[level - 1] + len + level - 1)  // Plus "/"
            } else {
                sum[level] = sum[level - 1] + len
            }
        }
        
        return result 
    }
}

extension String {
    
    func charAt(_ i: Int) -> Character {
        let index = self.index(self.startIndex, offsetBy: i)
        return self[index]
    }
}