[Swift]LeetCode1079. 活字印刷 | Letter Tile Possibilities

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

You have a set of tiles, where each tile has one letter tiles[i] printed on it.  Return the number of possible non-empty sequences of letters you can make.

Example 1:

Input: "AAB"
Output: 8
Explanation: The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".

Example 2:

Input: "AAABBC"
Output: 188

Note:

1. 1 <= tiles.length <= 7
2. tiles consists of uppercase English letters.

---

你有一套活字字模 tiles，其中每个字模上都刻有一个字母 tiles[i]。返回你可以印出的非空字母序列的数目。

示例 1：

输入："AAB"
输出：8
解释：可能的序列为 "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA"。

示例 2：

输入："AAABBC"
输出：188 

提示：

1. 1 <= tiles.length <= 7
2. tiles 由大写英文字母组成

---

Runtime: 12 ms

Memory Usage: 22.5 MB

class Solution {
    func numTilePossibilities(_ tiles: String) -> Int {
        let arr:[Character] = Array(tiles)
        let len:Int = tiles.count
        var cnt:[Character:Int] = [Character:Int]()
        var ans:Int = 0
        for i in 0..<len
        {
            cnt[arr[i],default: 0] += 1
        }
        var tab:[Int] = [Int]()
        cnt.dropLast()
        for val in cnt.values
        {
            tab.append(val)
        }
        dfs(&tab, &ans)
        return ans
    }
    
    func dfs(_ tab:inout [Int],_ ans:inout Int)
    {
        for i in 0..<tab.count
        {
            if tab[i] > 0
            {
                ans += 1
                tab[i] -= 1
                dfs(&tab,&ans)
                tab[i] += 1
            }
        }
    }
}

//String扩展
extension String {
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
}

---

20ms 

class Solution {
    var memo = [String:Int]()
    func helper(_ tiles: String, _ n: Int) -> Int {
        guard n > 0 else { return 1 }
        var visited = Set<Character>()
        var count = 0
        for i in 0..<tiles.count {
            let index = tiles.index(tiles.startIndex, offsetBy: i)
            let char = tiles[index]
            guard !visited.contains(char) else { continue }
            visited.insert(char)
            var newTiles = tiles
            newTiles.remove(at: index)
            let key = newTiles + String(n - 1)
            if memo[key] == nil {
                memo[key] = helper(newTiles, n - 1)
            }
            count += memo[key]!
        }
        return count
    }
    
    func numTilePossibilities(_ tiles: String) -> Int {
        return (1...tiles.count)
            .map { helper(tiles, $0) }
            .reduce(0, +)
    }
}

---

84ms

class Solution {
    func helper(_ tiles: String, _ n: Int) -> Int {
        guard n > 0 else { return 1 }
        
        var visited = Set<Character>()
        var count = 0
        for i in 0..<tiles.count {
            let index = tiles.index(tiles.startIndex, offsetBy: i)
            let char = tiles[index]
            guard !visited.contains(char) else { continue }
            visited.insert(char)
            var newTiles = tiles
            newTiles.remove(at: index)
            count += helper(newTiles, n - 1)
        }
        return count
    }
    
    func numTilePossibilities(_ tiles: String) -> Int {
        var count = 0
        for i in 1...tiles.count {
            count += helper(tiles, i)
        }
        return count
    }
}

---

116ms

class Solution {
    
    func dfs( freq: inout [Character : Int]) -> Int {
    var count = 0
    
    for letter in freq {
        if letter.value > 0 {
            count += 1
            freq[letter.key]! -= 1
            count += dfs(freq: &freq)
            freq[letter.key]! += 1
        }
    }
    return count
}
    
    func numTilePossibilities(_ tiles: String) -> Int {
            var freq : [Character : Int] = [:]
    for tile in tiles {
        freq[tile, default:0] += 1
    }
    
    return dfs(freq: &freq) 
    }
}

---

204ms

class Solution {
    func numTilePossibilities(_ tiles: String) -> Int {
        var cache: Set<String> = Set<String>()
             
        numFor(tile: tiles, cache: &cache)
        
        return cache.count
    }
    
    private func numFor(tile: String, cache: inout Set<String>) {
        // print("tile=(tile), cache=(cache)")
        guard cache.contains(tile) == false else {
            return 
        }
        guard tile.count > 0 else {
            return
        }
        
        cache.insert(tile)
        
        for i in 1 ..< tile.count {
            var temp = tile
            let char = temp.remove(at: tile.index(tile.startIndex, offsetBy: i))
            numFor(tile: String(char), cache: &cache)
            numFor(tile: temp, cache: &cache)
            numFor(tile: String(char) + temp, cache: &cache)
        }
    }
}

---

212ms

class Solution {
    func numTilePossibilities(_ tiles: String) -> Int {
        var chars = Array(tiles)
        var set = Set<String>()
        var isVisited = [Bool](repeating: false, count: tiles.count)
        var result = 0
        findSeq(chars, &set, &isVisited, "")
        // print(set)
        return set.count
    }
    
    fileprivate func findSeq(_ chars: [Character], _ set: inout Set<String>, _ isVisited: inout [Bool], _ path: String) {
        var count = 0
        for item in isVisited {
            if item == false { count += 1 }
        }
        if count == 0 { return }
        
        
        for i in 0...chars.count-1 {
            guard !isVisited[i] else {
                continue 
            }
            let curr = path + String(chars[i])
            if !set.contains(curr) { set.insert(curr) }
            isVisited[i] = true
            findSeq(chars, &set, &isVisited, curr)
            isVisited[i] = false
        }
    }
}

---

224ms

class Solution {
    var res = Set<String>()
    func helper(_ chars: [Character], _ n: Int, _ selected: String) {
        guard n > 0 else {
            res.insert(selected)
            return
        }
        for i in 0..<chars.count {
            var newChars = chars
            let newSelect = newChars.remove(at: i)
            helper(newChars, n - 1, selected + String(newSelect))
        }
        
    }
    func numTilePossibilities(_ tiles: String) -> Int {
        let chars = Array(tiles)
        
        for i in 1...tiles.count {
            helper(chars, i, "")
        }
        return res.count
    }
}

---

232ms

class Solution {
    private var sets = Set<String>()
    func backtrack(_ chars: inout [Character], _ i: Int) {
        if (i >= 1) {
            let str = String(chars[0..<i])
            sets.insert(str)
        }
        if i == chars.count { return }
        for j in i ..< chars.count {
            chars.swapAt(i, j)
            backtrack(&chars, i + 1)
            chars.swapAt(i, j)
        }
    }

    func numTilePossibilities(_ tiles: String) -> Int {
        var chars = Array(tiles)
        backtrack(&chars, 0)
        return sets.count
    }
}