[Swift]LeetCode679. 24点游戏 | 24 Game

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

You have 4 cards each containing a number from 1 to 9. You need to judge whether they could operated through *, /, +, -, (, )to get the value of 24.

Example 1:

Input: [4, 1, 8, 7]
Output: True
Explanation: (8-4) * (7-1) = 24

Example 2:

Input: [1, 2, 1, 2]
Output: False 

Note:

1. The division operator / represents real division, not integer division. For example, 4 / (1 - 2/3) = 12.
2. Every operation done is between two numbers. In particular, we cannot use - as a unary operator. For example, with [1, 1, 1, 1] as input, the expression -1 - 1 - 1 - 1 is not allowed.
3. You cannot concatenate numbers together. For example, if the input is [1, 2, 1, 2], we cannot write this as 12 + 12.

---

你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，(，) 的运算得到 24。

示例 1:

输入: [4, 1, 8, 7]
输出: True
解释: (8-4) * (7-1) = 24

示例 2:

输入: [1, 2, 1, 2]
输出: False

注意:

1. 除法运算符 / 表示实数除法，而不是整数除法。例如 4 / (1 - 2/3) = 12 。
2. 每个运算符对两个数进行运算。特别是我们不能用 - 作为一元运算符。例如，[1, 1, 1, 1] 作为输入时，表达式 -1 - 1 - 1 - 1 是不允许的。
3. 你不能将数字连接在一起。例如，输入为 [1, 2, 1, 2] 时，不能写成 12 + 12 。

---

16ms

class Solution {
    func oneOperation(_ nums: [Double], _ i: Int, _ j: Int,  
                      _ op: (Double, Double)->Double?) -> [Double]? {
        var arr = [Double]()
        for k in 0..<nums.count {
            if k != i && k != j {
                arr.append(nums[k])
            } 
        }
        if let num = op(nums[i], nums[j]) {
            arr.append(num)
            return arr
        } else {
            return nil
        }
    }
    func judgePoint24Internal(_ nums: [Double]) -> Bool {
        if nums.count == 2 {
            return nums[0]*nums[1] == 24 || nums[0]+nums[1] == 24 
                || nums[0] - nums[1] == 24 || nums[1] - nums[0] == 24
                || (nums[0] != 0 && 24.0-0.00001 < nums[1]/nums[0] && nums[1]/nums[0] < 24.0 + 0.0000001) 
                || (nums[1] != 0 && fabs(nums[0]/nums[1]-24.0) < 0.00001)
        }
             
        for i in 0..<nums.count-1 {
            for j in i+1..<nums.count {
                var arr = oneOperation(nums, i, j, {$0+$1})
                if judgePoint24Internal(arr!) == true {
                    return true
                }
                
                arr = oneOperation(nums, i, j, {$0*$1})
                if judgePoint24Internal(arr!) == true {
                    return true
                }
                
                arr = oneOperation(nums, i, j, {$0-$1})
                if judgePoint24Internal(arr!) == true {
                    return true
                }
                
                arr = oneOperation(nums, i, j, {$1 != 0 ? $0/$1 : nil})
                if let arr = arr, judgePoint24Internal(arr) == true {
                    return true
                }
                arr = oneOperation(nums, i, j, {$1-$0})
                if judgePoint24Internal(arr!) == true {
                    return true
                }
                
                arr = oneOperation(nums, i, j, {$0 != 0 ? $1/$0 : nil})
                if let arr = arr, judgePoint24Internal(arr) == true {
                    return true
                }
            }
        }
        return false
    }
    
    func judgePoint24(_ nums: [Int]) -> Bool {
        return judgePoint24Internal(nums.map{Double($0)})
    }
}

---

40ms

class Solution {
    func judgePoint24(_ nums: [Int]) -> Bool {
        return solve(nums.map { Double($0) })
    }
    
    private func solve(_ nums: [Double]) -> Bool {
        guard nums.count > 1 else {
            return abs(nums[0] - 24.0) < 1e-6
        }
        
        for i in 0..<nums.count {
            for j in 0..<nums.count {
                guard i != j else {
                    continue
                }
                
                var newNums = [Double]()
                for k in 0..<nums.count where k != i && k != j {
                    newNums.append(nums[k])
                }
                
                for k in 0..<4 {
                    switch k {
                    case 0:
                        newNums.append(nums[i] + nums[j])
                    case 1:
                        newNums.append(nums[i] - nums[j])
                    case 2:
                        newNums.append(nums[i] * nums[j])
                    case 3:
                        if nums[j] != 0.0 {
                            newNums.append(nums[i] / nums[j])
                        } else {
                            continue
                        }
                    default:
                        continue
                    }
                    if solve(newNums) {
                        return true
                    }
                    newNums.removeLast()
                }
            }
        }
        return false
    }
}

---

44ms

class Solution {    
    private let esp: Double = 0.001
    
    func judgePoint24(_ nums: [Int]) -> Bool {
        var nums = nums.map { return Double($0) }
        return dfs(nums)
    }
    
    private func dfs(_ nums: [Double]) -> Bool {
        if nums.count == 1 {
            if abs(nums.first! - 24) <= esp {
                return true
            } else {
                return false
            }
        }
        
        for i in 0 ..< nums.count {
            for j in i + 1 ..< nums.count {
                var next: [Double] = []
                
                for k in 0 ..< nums.count {
                    if k != i && k != j {
                        next.append(nums[k])
                    }
                }
                
                let p1 = nums[i]
                let p2 = nums[j]
                let combines = [p1 + p2, p1 - p2, p2 - p1, p1 * p2, p1 / p2, p2 / p1]
                
                for c in combines {
                    next.append(c)
                    if dfs(next) {
                        return true
                    }
                    next.removeLast()
                }
            }
        }        
        return false
    }
}