[Swift]LeetCode1032. 字符流 | Stream of Characters

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

Implement the StreamChecker class as follows:

• StreamChecker(words): Constructor, init the data structure with the given words.
• query(letter): returns true if and only if for some k >= 1, the last k characters queried (in order from oldest to newest, including this letter just queried) spell one of the words in the given list.

Example:

StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // init the dictionary.
streamChecker.query('a');          // return false
streamChecker.query('b');          // return false
streamChecker.query('c');          // return false
streamChecker.query('d');          // return true, because 'cd' is in the wordlist
streamChecker.query('e');          // return false
streamChecker.query('f');          // return true, because 'f' is in the wordlist
streamChecker.query('g');          // return false
streamChecker.query('h');          // return false
streamChecker.query('i');          // return false
streamChecker.query('j');          // return false
streamChecker.query('k');          // return false
streamChecker.query('l');          // return true, because 'kl' is in the wordlist

Note:

• 1 <= words.length <= 2000
• 1 <= words[i].length <= 2000
• Words will only consist of lowercase English letters.
• Queries will only consist of lowercase English letters.
• The number of queries is at most 40000.

---

按下述要求实现 StreamChecker 类：

• StreamChecker(words)：构造函数，用给定的字词初始化数据结构。
• query(letter)：如果存在某些 k >= 1，可以用查询的最后 k个字符（按从旧到新顺序，包括刚刚查询的字母）拼写出给定字词表中的某一字词时，返回 true。否则，返回 false。

示例：

StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // 初始化字典
streamChecker.query('a');          // 返回 false
streamChecker.query('b');          // 返回 false
streamChecker.query('c');          // 返回 false
streamChecker.query('d');          // 返回 true，因为 'cd' 在字词表中
streamChecker.query('e');          // 返回 false
streamChecker.query('f');          // 返回 true，因为 'f' 在字词表中
streamChecker.query('g');          // 返回 false
streamChecker.query('h');          // 返回 false
streamChecker.query('i');          // 返回 false
streamChecker.query('j');          // 返回 false
streamChecker.query('k');          // 返回 false
streamChecker.query('l');          // 返回 true，因为 'kl' 在字词表中。

提示：

• 1 <= words.length <= 2000
• 1 <= words[i].length <= 2000
• 字词只包含小写英文字母。
• 待查项只包含小写英文字母。
• 待查项最多 40000 个。

---

2156ms

let alphaMap: [Character: Int] = [
    "a": 0,
    "b": 1,
    "c": 2,
    "d": 3,
    "e": 4,
    "f": 5,
    "g": 6,
    "h": 7,
    "i": 8,
    "j": 9,
    "k": 10,
    "l": 11,
    "m": 12,
    "n": 13,
    "o": 14,
    "p": 15,
    "q": 16,
    "r": 17,
    "s": 18,
    "t": 19,
    "u": 20,
    "v": 21,
    "w": 22,
    "x": 23,
    "y": 24,
    "z": 25
]

class Node {
    var val: Character
    var next: Node?
    var prev: Node?

    init(_ val: Character) {
        self.val = val
    }
}


class LinkedList {
    private(set) var head = Node(".")
    private(set) var tail = Node(".")

    init() {
        head.next = tail
        tail.prev = head
    }

    func add(node: Node) {
        node.next = head.next
        node.prev = head
        head.next?.prev = node
        head.next = node
    }

    func removeLast() {
        tail.prev?.prev?.next = tail
        tail.prev = tail.prev?.prev
    }
    
    func snapshot() {
        var node = head.next
        var str = ""
        while let n = node,
            n !== tail {
                str += "(n.val)"
                node = n.next
                if node !== tail {
                    str += " -> "
                }
        }
    }
}

class Trie {
    private(set) var nodes: [Trie?] = [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
    var isEnd = false
    
    func add(character: Character) -> Trie? {
        let index = alphaMap[character]!
        if nodes[index] == nil {
            nodes[index] = Trie()
        }
        return nodes[index]
    }
    
    func find(character: Character) -> Trie? {
        let index = alphaMap[character]!
        return nodes[index]
    }
}

class StreamChecker {

    private var trie = Trie()
    private var buffer = LinkedList()
    private var bufferCount = 0
    private var maxCount = 0

    init(_ words: [String]) {
        for word in words {
            var currentTrie: Trie? = trie
            var count = 0
            for char in word.reversed() {
                currentTrie = currentTrie?.add(character: char)
                count += 1
            }
            maxCount = max(maxCount, count)
            currentTrie?.isEnd = true
        }
    }

    func query(_ letter: Character) -> Bool {
        buffer.add(node: Node(letter))
        bufferCount += 1
        if bufferCount > maxCount {
            bufferCount -= 1
            buffer.removeLast()
        }
        var node = buffer.head.next
        var currentTrie: Trie? = trie
        while let n = node, n !== buffer.tail, let trie = currentTrie {
            currentTrie = trie.find(character: n.val)
            if currentTrie?.isEnd ?? false { return true }
            node = n.next
        }
        return false
    }
}

---

Runtime: 2240 ms

Memory Usage: 32.3 MB

class StreamChecker {
    var root:TrieNode?
    var stream:[Int]
    init(_ words: [String]) {
        stream = [Int]()
        root = TrieNode()
        for word in words
        {
            var arrWord:[Int] = Array(word).map{$0.ascii - 97}
            var m:Int = word.count
            var cur:TrieNode? = root
            for i in stride(from:m - 1,through:0,by:-1)
            {
                if cur?.children[arrWord[i]] == nil
                {
                    cur?.children[arrWord[i]] = TrieNode()
                }
                cur = cur?.children[arrWord[i]]
            }            
            cur?.is_word = true;
        }        
    }
    
    func query(_ letter: Character) -> Bool {
        stream.append(letter.ascii)
        var m:Int = stream.count
        var cur:TrieNode? = root
        for i in stride(from:m - 1,through:0,by:-1)
        {
            cur = cur?.children[stream[i] - 97]
            if cur == nil {return false}
            else if cur!.is_word {return true}
        }
        return false
    }
}

class TrieNode{
    var is_word:Bool
    var children:[TrieNode?]
    init()
    {
        is_word = false
        children = [TrieNode?](repeating:nil,count:26)
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }
}

/**
 * Your StreamChecker object will be instantiated and called as such:
 * let obj = StreamChecker(words)
 * let ret_1: Bool = obj.query(letter)
 */