好题啊！

递归。4张牌变为24，实际上是每次拿两张牌变为1张，然后和另外的所有牌放在一起再递归。

⚠️注意点：

  1. 这两张牌6种加减乘除操作得到的结果，每次只能选1个加入newList;
  2. 因为涉及double类型的除法，所以和24比较要用epsilon法不能完全相等。

其实下面的两层for循环可以看出，每两张牌对应一个for嵌套，一个newList, 实际上是看这两张牌组合和剩下的组合起来能不能成24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public boolean judgePoint24(int[] nums) {
    List<Double> list = new ArrayList<>();
    for (int i : nums) {
        list.add((double) i);
    }
    return recursion(list);
}

private boolean recursion(List<Double> list) {
    // recursive: 开头部分都是递归终止条件
    if (list.size() == 1) {
        if (Math.abs(list.get(0) - 24.0) < 0.001) return true;
        return false;
    }
    
    for (int i = 0; i < list.size(); ++i) {
        for (int j = i + 1; j < list.size(); ++j) {
            
            List<Double> newList = new ArrayList<>();
            for (int k=0; k < list.size(); ++k) {
                if (k != i && k != j) newList.add(list.get(k));
            }
            
            double a = list.get(i), b = list.get(j);
            
            newList.add(a + b);
            if (recursion(newList)) return true;
            
            newList.set(newList.size() - 1, a - b);
            if (recursion(newList)) return true;
            
            newList.set(newList.size() - 1, b - a);
            if (recursion(newList)) return true;
            
            newList.set(newList.size() - 1, a * b);
            if (recursion(newList)) return true;
            
            newList.set(newList.size() - 1, a / b);
            if (recursion(newList)) return true;
            
            newList.set(newList.size() - 1, b / a);
            if (recursion(newList)) return true;
        }
    }
    
    return false;
}

上面的set, 当然可以用一个function单独写出来，但是那样变慢了而且内存消耗增加。