[Swift]LeetCode1178. 猜字谜 | Number of Valid Words for Each Puzzle

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

With respect to a given puzzle string, a word is valid if both the following conditions are satisfied:

• word contains the first letter of puzzle.
• For each letter in word, that letter is in puzzle.
  For example, if the puzzle is "abcdefg", then valid words are "faced", "cabbage", and "baggage"; while invalid words are "beefed" (doesn't include "a") and "based" (includes "s" which isn't in the puzzle).

Return an array answer, where answer[i] is the number of words in the given word list words that are valid with respect to the puzzle puzzles[i].

Example :

Input: 
words = ["aaaa","asas","able","ability","actt","actor","access"], 
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
Output: [1,1,3,2,4,0]
Explanation:
1 valid word for "aboveyz" : "aaaa" 
1 valid word for "abrodyz" : "aaaa"
3 valid words for "abslute" : "aaaa", "asas", "able"
2 valid words for "absoryz" : "aaaa", "asas"
4 valid words for "actresz" : "aaaa", "asas", "actt", "access"
There're no valid words for "gaswxyz" cause none of the words in the list contains letter 'g'.

Constraints:

• 1 <= words.length <= 10^5
• 4 <= words[i].length <= 50
• 1 <= puzzles.length <= 10^4
• puzzles[i].length == 7
• words[i][j], puzzles[i][j] are English lowercase letters.
• Each puzzles[i] doesn't contain repeated characters.

---

 外国友人仿照中国字谜设计了一个英文版猜字谜小游戏，请你来猜猜看吧。

字谜的迷面 puzzle 按字符串形式给出，如果一个单词 word 符合下面两个条件，那么它就可以算作谜底：

• 单词 word 中包含谜面 puzzle 的第一个字母。
• 单词 word 中的每一个字母都可以在谜面 puzzle 中找到。
  例如，如果字谜的谜面是 "abcdefg"，那么可以作为谜底的单词有 "faced", "cabbage", 和 "baggage"；而 "beefed"（不含字母 "a"）以及 "based"（其中的 "s" 没有出现在谜面中）。

返回一个答案数组 answer，数组中的每个元素 answer[i] 是在给出的单词列表 words 中可以作为字谜迷面 puzzles[i] 所对应的谜底的单词数目。

示例：

输入：
words = ["aaaa","asas","able","ability","actt","actor","access"], 
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
输出：[1,1,3,2,4,0]
解释：
1 个单词可以作为 "aboveyz" 的谜底 : "aaaa" 
1 个单词可以作为 "abrodyz" 的谜底 : "aaaa"
3 个单词可以作为 "abslute" 的谜底 : "aaaa", "asas", "able"
2 个单词可以作为 "absoryz" 的谜底 : "aaaa", "asas"
4 个单词可以作为 "actresz" 的谜底 : "aaaa", "asas", "actt", "access"
没有单词可以作为 "gaswxyz" 的谜底，因为列表中的单词都不含字母 'g'。

提示：

• 1 <= words.length <= 10^5
• 4 <= words[i].length <= 50
• 1 <= puzzles.length <= 10^4
• puzzles[i].length == 7
• words[i][j], puzzles[i][j] 都是小写英文字母。
• 每个 puzzles[i] 所包含的字符都不重复。

---

Runtime: 656 ms

Memory Usage: 36.7 MB

class Solution {
    func findNumOfValidWords(_ words: [String], _ puzzles: [String]) -> [Int] {
        var result:[Int] = [Int]()
        var wordSets:[Int:Int] = [Int:Int]()
        var puzzles = puzzles.map{Array($0).map{$0.ascii}}
        var words = words.map{Array($0).map{$0.ascii - 97}}
        // Encode word of 26 chars in 31 bit (signed Int)
        for i in 0..<words.count
        {
            var bits:Int = 0
            for j in 0..<words[i].count
            {
                bits |= 1 << words[i][j]
            }
            wordSets[bits,default:0] += 1
        }

        for i in 0..<puzzles.count
        {
            var bits:Int = 0
            var firstCharBitSet = 1 << (puzzles[i][0] - 97)
            for j in 0..<puzzles[i].count
            {
                bits |= 1 << (puzzles[i][j] - 97)
            }
            var count:Int = 0
            var b:Int = bits
            while(b > 0)
            {
                if (b & firstCharBitSet) != 0 && wordSets[b] != nil
                {
                    count += wordSets[b]!
                }
                b = --b & bits
            }
            result.append(count)
        }
        return result
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }
}
    
/*扩展Int类，实现自增++、自减--运算符*/
extension Int{
    //--前缀:先自减再执行表达示
    static prefix func --(num:inout Int) -> Int {
        //输入输出参数num
        num -= 1
        //返回减1后的数值
        return num
    }
}

---

1020ms

class Solution {
    func findNumOfValidWords(_ words: [String], _ puzzles: [String]) -> [Int] {        
        let table = Array("abcdefghijklmnopqrstuvwxyz")
        var dic = [Character: Int](), i = 0
        for c in table {
            dic[c] = i
            i += 1
        }
        var ans = [Int]()
        var freq = [Int](repeating: 0, count: 1<<26)
        for w in words {
            let cw = Array(w)
            var mask = 0
            for c in cw {
                mask |= 1<<dic[c]!
            }
            freq[mask] += 1
        }
        for p in puzzles {
            let cp = Array(p)
            var mask = 0
            for c in cp {
                mask |= 1<<dic[c]!
            }

            let first = dic[cp.first!]!
            var sub = mask
            var total = 0
            while true {
                if sub >> first & 1 != 0 {
                    total += freq[sub]
                }
                if sub == 0 {
                    break
                }
                sub = (sub-1)&mask
            }
            ans.append(total)
        }
        return ans
    }
}

---

1908ms

class Solution {
    func findNumOfValidWords(_ words: [String], _ puzzles: [String]) -> [Int] {
        let trie = Trie()
        var result = [Int]()
        
        for word in words {
            trie.insert(String(Set(word).sorted()))
        }
        
        for puzzle in puzzles {
            let firstCharacter = puzzle[String.Index(encodedOffset: 0)]
            let sortedPuzzle = String(puzzle.sorted())
            
            result.append(trie.search(sortedPuzzle, firstCharacter, false))
        }
        
        return result
    }
}

class TrieNode {
    var hash = [Character:TrieNode]()
    var countOfWords = 0
    
    func search(_ word: String, _ firstChar: Character, _ firstSeen: Bool) -> Int {
        var count = 0
        
        if firstSeen { 
            count += countOfWords 
        }
        
        for i in 0..<word.count {
            let wordChar = word[String.Index(encodedOffset: i)]
            
            guard let childNode = hash[wordChar] else { continue }
            
            if wordChar == firstChar {
                count += childNode.search(word, firstChar, true)
            } else {
                count += childNode.search(word, firstChar, firstSeen)
            }
            
        }
        
        return count
    }
}

class Trie {
    let root = TrieNode()
    
    init(_ words: [String] = []) {
        words.forEach(insert)
    }
    
    func search(_ word: String, _ firstChar: Character, _ firstSeen: Bool) -> Int {
        return root.search(word, firstChar, firstSeen)
    }
    
    func insert(_ word: String) {
        var current = root
        for character in word {
            if let node = current.hash[character] {
                current = node
            } else {
                current.hash[character] = TrieNode()
                current = current.hash[character]!
            }
        }
        current.countOfWords += 1
    }
}