Leetcode: 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:
The division operator / represents real division, not integer division. For example, 4 / (1 - 2/3) = 12.
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.
You cannot concatenate numbers together. For example, if the input is [1, 2, 1, 2], we cannot write this as 12 + 12.

Backtracking: every time draw two cards, calculate the possible results, and add one result to the nextRound list.

The nextRound list will have the remaining unused cards. 

Every round the nextRound list will decrease its size by 1.

Repeat the process until nextRound list decrease to size 1.

 

 

class Solution {
    public boolean judgePoint24(int[] nums) {
        List<Double> list = new ArrayList<>();
        for (int num : nums) {
            list.add((double)num);
        }
        return backtracking(list);
    }
    
    public boolean backtracking(List<Double> list) {
        if (list.size() == 1) {
            if (Math.abs(list.get(0) - 24.0) < 0.001) {
                return true;
            }
            return false;
        }
        
        // every time backtracking: always draw two cards
        for (int i = 0; i < list.size(); i ++) {
            for (int j = i + 1; j < list.size(); j ++) {
                
                // for each possible result of the two card-combination
                for (double c : compute(list.get(i), list.get(j))) {
                    List<Double> nextRound = new ArrayList<>();
                    nextRound.add(c);
                    
                    for (int k = 0; k < list.size(); k ++) {
                        if (k != i && k != j) 
                            nextRound.add(list.get(k));
                    }
                                    
                    if (backtracking(nextRound)) return true;
                }
            }
        }
        return false;
    }
    
    // compute the possible result of a combination
    public List<Double> compute(double a, double b) {
        return Arrays.asList(a + b, a - b, b - a, a * b, a / b, b / a);
    }
}