679. 24 Game

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.

24点计算，回溯算法求解，程序如下所示：

class Solution {
    List<Double> list = new ArrayList<>();
    public boolean judgePoint24(int[] nums) {
        for (int val : nums){
            list.add((double)val);
        }
        return calculate(list);
    }
    
    public boolean calculate(List<Double> list){
        if (list.size() == 0){
            return false;
        }
        if (list.size() == 1){
            return Math.abs(list.get(0) - 24) < 1e-6;
        }
        for (int i = 0; i < list.size(); ++ i){
            for (int j = 0; j < list.size(); ++ j){
                if (i != j){
                    List<Double> l = new ArrayList<>();
                    for (int t = 0; t < list.size(); ++ t){
                        if (t != i && t != j){
                            l.add(list.get(t));
                        }
                    }
                    for (int k = 0; k < 4; ++ k){
                        if (k == 0){
                            l.add(list.get(i) + list.get(j));
                        }
                        if (k == 1){
                            l.add(list.get(i) - list.get(j));
                        }
                        if (k == 2){
                            l.add(list.get(i) * list.get(j));
                        }
                        if (k == 3){
                            if (list.get(j) == 0){
                                continue;
                            }
                            l.add(list.get(i)/list.get(j));
                        }
                        if (calculate(l)){
                            return true;
                        }
                        l.remove(l.size() - 1);
                    }
                }
            }
        }
        return false;
    }
}