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.

思路：不要考虑括号的迷惑，就是a,b可以有+-*/任何组合就行了。那么这题就变为了backtracking，每次取两个值，进行计算，compute之后有(a + b, a - b, a * b, a / b, b - a, b / a)，然后隐式图搜索，加入其中一个数继续dfs, 最后计算成1个值的时候跟24判断一下，如果接近就是true，否则就是false；经典backtracking；

class Solution {
    public boolean judgePoint24(int[] cards) {
        if(cards == null || cards.length == 0) {
            return false;
        }
        List<Double> list = new ArrayList<Double>();
        for(int card: cards) {
            list.add((double) card);
        }
        return dfs(list);
    }
    
    private boolean dfs(List<Double> list) {
        if(list.size() == 1) {
            // 记住，比较绝对值大小
            return Math.abs(list.get(0) - 24.0)<= 1e-5;
        }   
        for(int i = 0; i < list.size(); i++) {
            for(int j = i + 1; j < list.size(); j++) {
                List<Double> remain = remove(list, i, j);
                for(Double calres: getCalculateResult(list.get(i), list.get(j))) {
                    remain.add(calres);
                    if(dfs(remain)) {
                        return true;
                    }
                    remain.remove(remain.size() - 1);
                }
            }
        }
        return false;
    }
    
    private List<Double> remove(List<Double> list, int i, int j) {
        List<Double> res = new ArrayList<>();
        for(int k = 0; k < list.size(); k++) {
            if(k != i && k != j) {
                res.add(list.get(k));
            }
        }
        return res;
    }
    
    private List<Double> getCalculateResult(double a, double b) {
        List<Double> list = new ArrayList<Double>();
        list.add(a + b);
        list.add(a - b); list.add(b - a);
        list.add(a * b);
        list.add(a / b); list.add(b / a);
        return list;
    }
}