leetcode679(24点游戏：回溯法）

你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，( ) 的运算得到 24。
输入: [4, 1, 8, 7]
输出: True
解释: (8-4) * (7-1) = 24

题解：穷举法，无脑列出所有可能的情况，一个一个判断结果是否等于24，具体的方式是通过回溯算法，利用递归实现所有可能的情况的复现——每一次计算的形式都是：数字A 符号B 数字C = 数字D，第一次计算时，可选数字一共有4个，两个数字A、B一共有43=12种情况，符号共有四种，所以第一次计算共有124=48种情况，第二次计算时可选数字有三个（第一次计算所得结果包含在内），符号依旧是4个，同理，第二次计算有324=24种情况，依次类推，一共有9216种情况。

class Solution {
    
    
                static final int ADD=0;
                static final int SUBTRACT=1;
                static final int MULTIPLY=2;
                static final int DIVISION=3;
                boolean res=false;
                static final double ERROR =0.0000001;
                public boolean judgePoint24(int[] nums) {
    
    
                    double[] arg=new double[nums.length];
                   for(int i=0;i< nums.length;i++)
                       arg[i]=nums[i];
                   DFS(arg);
                   return res;
                }
                private  void DFS(double[]nums) {
    
    
                    if(nums.length==1){
    
    
                        if(Math.abs(nums[0]-24)<= ERROR)
                            res = true;
                        return;
                    }
                    double[] arg = new double[nums.length - 1];
                    for (int i = 0; i < nums.length ; i++)
                        for (int k = 0; k < nums.length; k++)
                            for (int m = 0; m < 4; m++) {
    
    
                                if (k == i)
                                    continue;
                                double subRes;
                                if (m == ADD) {
    
    
                                    subRes = nums[i] + nums[k];

                                } else if (m == SUBTRACT) {
    
    
                                    subRes = nums[i] - nums[k];

                                } else if (m == MULTIPLY) {
    
    

                                    subRes = nums[i] * nums[k];
                                } else {
    
    
                                    subRes = nums[i] / nums[k];

                                }
                                boolean[] pick = new boolean[nums.length];
                                pick[i]=true;
                                pick[k] = true;
                                for (int n = 0; n < arg.length - 1; n++) {
    
    
                                    for (int j = 0; j < nums.length; j++) {
    
    
                                        if (!pick[j]) {
    
    
                                            arg[n] = nums[j];
                                            pick[j] = true;
                                            break;
                                        }

                                    }
                                }
                                arg[arg.length - 1] = subRes;
                                DFS(arg);

                             }
                       }