題目 24點程式

描述

你有 4 張寫有 1 到 9 數字的牌。你需要判斷是否能通過 *，/，+，-，(，) 的運算得到 24。

示例 1:

輸入: [4, 1, 8, 7]
輸出: True
解釋: (8-4) * (7-1) = 24
示例 2:

輸入: [1, 2, 1, 2]
輸出: False
注意:

除法運算子 / 表示實數除法，而不是整數除法。例如 4 / (1 - 2/3) = 12 。
每個運算子對兩個數進行運算。特別是我們不能用 - 作為一元運算子。例如，[1, 1, 1, 1] 作為輸入時，表示式 -1 - 1 - 1 - 1 是不允許的。
你不能將數字連線在一起。例如，輸入為 [1, 2, 1, 2] 時，不能寫成 12 + 12 。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/24-game

解析

知識點： 回溯

處理邏輯是從4張牌裡面進行選擇，每次由2張牌合為一張牌，進行下一輪處理，所以總共有3輪。
第一輪：從4張牌裡面任意選兩個進行4種操作，
第二輪：從3張牌裡面任意選兩個進行4種操作，
第三輪：從2張牌選兩個進行4中操作

可能的選擇和操作總數是，(12 * 4) * (6 * 4) * (2 * 4) = 9216種
12 * 4 就是4張牌裡面任意選前2個數的組合，這兩個數字進行4種操作
6 * 4 就是3張牌裡面任意選前2個數的組合，這兩個數字進行4種操作
2 * 4 就是2張牌裡面任意選前2個數的組合，已經4種操作後的結果。

舉例說明：假設為1 2 3 4 四個數字
4張牌全排列是4的階乘，4！= 24，由於要每次取兩個數字，
兩個一樣的數字如下會有重複的排列需要去重，
後面的數字部分是下一輪要考慮的，第一輪不考慮；
1 2 3 4, 1 2 4 3, 1 3 2 4, 1 3 4 3, 1 4 2 3, 1 4 3 2,
2 1 3 4, 2 1 4 3, 2 3 1 4, 2 3 4 1, 2 4 1 3, 2 4 3 1,
3 1 2 4, 3 1 4 2, 3 2 1 4, 3 2 4 1, 3 4 1 2, 3 4 2 1,

第二輪迴圈假設為 2 3 4 三個數字，可以看到有6中情況
2 3 4, 2 4 3, 3 2 4, 3 4 2, 4 2 3, 4 3 2

第三輪迴圈假設為 4 6 兩個數字，所以是兩種情況，但是裡面 + 和 * 的結果是一樣的，當時 / 和 - 會不同
4 6，6 4

程式碼如下：

class Solution {
    public boolean judgePoint24(int[] nums) {
        ArrayList<Double> A = new ArrayList<>();
        for (int v: nums) A.add((double) v);
        return solve(A);
    }

    private boolean solve(ArrayList<Double> nums) {
        // 沒有可計算的，證明無解
        if (nums.size() == 0) return false;
        // le-6是浮點計算的精度誤差，這裡判斷誤差小於1e-6，這樣就是正確結果
        if (nums.size() == 1) return Math.abs(nums.get(0) - 24) < 1e-6;


        for (int i = 0; i < nums.size(); i++) {
            for (int j = 0; j < nums.size(); j++) {
                if (i != j) {
                    // 找到當前排列下的其他兩個元素
                    ArrayList<Double> nums2 = new ArrayList<>();
                    for (int k = 0; k < nums.size(); k++) {
                        if (k != i && k != j) {
                            nums2.add(nums.get(k));
                        }
                    }

                    // k的四種計算情況
                    for (int k = 0; k < 4; k++) {
                        // 效能優化，當k<2時，對於+ or *不考慮順序，
                        // 所以k<2 時，j > i與i > j的結果相同，所以有部分不用考慮
                        if (k < 2 && j > i) continue;
                        if (k == 0) nums2.add(nums.get(i) + nums.get(j));
                        if (k == 1) nums2.add(nums.get(i) * nums.get(j));
                        if (k == 2) nums2.add(nums.get(i) - nums.get(j));
                        // 避免除數為0
                        if (k == 3) {
                            if (nums.get(j) != 0) {
                                nums2.add(nums.get(i) / nums.get(j));
                            } else {
                                continue;
                            }
                        }
                        // 在這次計算後，判斷剩下的元素是否符合要求
                        // 每次縮小計算範圍
                        if (solve(nums2)) return true;
                        // 移除最後一個計算結果，因為最後的記過不滿足要求
                        // 就是一種回溯方法，將前面新增的結果刪除
                        nums2.remove(nums2.size() - 1);
                    }
                }
            }
        }
        return false;
    }
}