[Swift]LeetCode745. 前缀和后缀搜索 | Prefix and Suffix Search

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

Given many words, words[i] has weight i.

Design a class WordFilter that supports one function, WordFilter.f(String prefix, String suffix). It will return the word with given prefix and suffix with maximum weight. If no word exists, return -1.

Examples:

Input:
WordFilter(["apple"])
WordFilter.f("a", "e") // returns 0
WordFilter.f("b", "") // returns -1 

Note:

1. words has length in range [1, 15000].
2. For each test case, up to words.length queries WordFilter.fmay be made.
3. words[i] has length in range [1, 10].
4. prefix, suffix have lengths in range [0, 10].
5. words[i] and prefix, suffixqueries consist of lowercase letters only.

---

给定多个 words，words[i] 的权重为 i 。

设计一个类 WordFilter 实现函数WordFilter.f(String prefix, String suffix)。这个函数将返回具有前缀 prefix 和后缀suffix 的词的最大权重。如果没有这样的词，返回 -1。

例子:

输入:
WordFilter(["apple"])
WordFilter.f("a", "e") // 返回 0
WordFilter.f("b", "") // 返回 -1

注意:

1. words的长度在[1, 15000]之间。
2. 对于每个测试用例，最多会有words.length次对WordFilter.f的调用。
3. words[i]的长度在[1, 10]之间。
4. prefix, suffix的长度在[0, 10]之前。
5. words[i]和prefix, suffix只包含小写字母。

---

1760ms

class Node {
    var map = [Character: Node]()
    var weights = [Int]()
}

class WordFilter {
    private var maxDepth = 10
    private var forwardRoot = Node()
    private var backwardRoot = Node()
    init(_ words: [String]) {
        var forwardNode: Node?
        var backwardNode: Node?
        for (wIndex, word)in words.enumerated() {
            forwardNode = forwardRoot
            for char in word {
                if forwardNode?.map[char] == nil {
                    forwardNode?.map[char] = Node()
                }
                forwardNode?.weights.append(wIndex)
                forwardNode = forwardNode?.map[char]
            }
            forwardNode?.weights.append(wIndex)

            backwardNode = backwardRoot
            for char in word.reversed() {
                if backwardNode?.map[char] == nil {
                    backwardNode?.map[char] = Node()
                }
                backwardNode?.weights.append(wIndex)
                backwardNode = backwardNode?.map[char]
            }
            backwardNode?.weights.append(wIndex)
        }
    }

    func f(_ prefix: String, _ suffix: String) -> Int {
        var forwardNode: Node? = forwardRoot
        for char in prefix {
            guard let node = forwardNode else { break }
            forwardNode = node.map[char]
        }

        guard let fWeights = forwardNode?.weights,
            fWeights.count > 0 else { return -1 }

        var backwardNode: Node? = backwardRoot
        for char in suffix.reversed() {
            guard let node = backwardNode else { break }
            backwardNode = node.map[char]
        }

        guard let bWeights = backwardNode?.weights,
            bWeights.count > 0 else { return -1 }

        var fIndex = fWeights.count - 1
        var bIndex = bWeights.count - 1

        while fIndex >= 0, bIndex >= 0 {
            let fw = fWeights[fIndex]
            let bw = bWeights[bIndex]
            if fw == bw {
                return fw
            }
            if fw > bw {
                fIndex -= 1
            } else {
                bIndex -= 1
            }
        }
        return -1
    }
}

/**
 * Your WordFilter object will be instantiated and called as such:
 * let obj = WordFilter(words)
 * let ret_1: Int = obj.f(prefix, suffix)
 */

---

Runtime: 1768 ms

Memory Usage: 23.1 MB

class WordFilter {
    var mp:[String:[Int]] = [String:[Int]]()
    var ms:[String:[Int]] = [String:[Int]]()

    init(_ words: [String]) {
        for k in 0..<words.count
        {
            for i in 0...words[k].count
            {
                mp[words[k].subString(0, i),default:[Int]()].append(k)
            }
            for i in 0...words[k].count
            {
                ms[words[k].subString(words[k].count - i),default:[Int]()].append(k)
            }
        }
        
    }
    
    func f(_ prefix: String, _ suffix: String) -> Int {
        if mp[prefix] == nil || ms[suffix] == nil {return -1}
        var pre:[Int] = mp[prefix]!
        var suf:[Int] = ms[suffix]!
        var i:Int = pre.count - 1
        var j:Int = suf.count - 1
        while (i >= 0 && j >= 0)
        {
            if pre[i] < suf[j]
            {
                j -= 1
            }
            else if pre[i] > suf[j]
            {
                i -= 1
            }
            else
            {
                return pre[i]
            }            
        }       
        return -1      
    }
}

/**
 * Your WordFilter object will be instantiated and called as such:
 * let obj = WordFilter(words)
 * let ret_1: Int = obj.f(prefix, suffix)
 */
 
extension String {
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }   
    
    // 截取字符串：从index到结束处
    // - Parameter index: 开始索引
    // - Returns: 子字符串
    func subString(_ index: Int) -> String {
        let theIndex = self.index(self.endIndex, offsetBy: index - self.count)
        return String(self[theIndex..<endIndex])
    }
}

---

2024ms

class WordFilter {

    var map: [String: Int] = [:]
    
    init(_ words: [String]) {
        for i in 0 ..< words.count {
            insert(words[i], i)
        }
    }
    
    private func insert(_ word: String, _ index: Int) {
        var preList = [Substring]()
        var sufList = [Substring]()
        for i in 0 ... word.count {
            preList.append(word.prefix(i))
            sufList.append(word.suffix(i))
        }
        for x in preList {
            for y in sufList {
                map["(x)_(y)"] = index
            }
        }
    }
    
    func f(_ prefix: String, _ suffix: String) -> Int {
        return map["(prefix)_(suffix)"] ?? -1
    }
}

/**
 * Your WordFilter object will be instantiated and called as such:
 * let obj = WordFilter(words)
 * let ret_1: Int = obj.f(prefix, suffix)
 */

---

2200ms

class WordFilter {
    
    private class TrieNode {
        var children = [Character: TrieNode]()
        var index = -1
    }
    
    private var root: TrieNode
    
    init(_ words: [String]) {
        root = TrieNode()
        for i in 0 ..< words.count {
            insert(words[i], i)
        }
    }
    
    func insert(_ word: String, _ idx: Int) {
        let len = word.count
        let start = word.startIndex
        var i = len
        while i >= 0 {
            let newWord = word.substring(from: word.index(start, offsetBy: i))
            insertReal("(newWord)_(word)", idx)
            i -= 1
        }
    }
    
    func insertReal(_ word: String, _ idx: Int) {
        var p = root
        for c in word {
            if p.children[c] == nil {
                p.children[c] = TrieNode()
            }
            p = p.children[c]!
            p.index = idx
        }
    }
    
    func startWith(_ prefix: String) -> Int {
        var p = root
        for c in prefix {
            if let node = p.children[c] {
                p = node
            } else {
                return -1
            }
        }
        
        return p.index
    }
    
    func f(_ prefix: String, _ suffix: String) -> Int {
        return startWith("(suffix)_(prefix)")
    }
}


/**
 * Your WordFilter object will be instantiated and called as such:
 * let obj = WordFilter(words)
 * let ret_1: Int = obj.f(prefix, suffix)
 */

---

Time Limit Exceeded 

class WordFilter {
    var input:[String] = [String]()

    init(_ words: [String]) {
        input = words        
    }
    
    func f(_ prefix: String, _ suffix: String) -> Int {
        //注意enumerated()、reversed()的顺序
        for (index,str) in input.enumerated().reversed()
        {
            if str.hasPrefix(prefix) && str.hasSuffix(suffix)
            {
                return index
            }            
        }    
        return -1      
    }
}

/**
 * Your WordFilter object will be instantiated and called as such:
 * let obj = WordFilter(words)
 * let ret_1: Int = obj.f(prefix, suffix)
 */