leetcode 679 24点游戏

 思路参考官方

 其实就是先找出来两个数，然后根据运算符的不同计算出二者结果后，再把二者结果和剩余的两个刚才没找出来的数进行后续计算，这里就可以采用递归了，从三个里选两个。到最后就只剩一个计算结果了。然后判断是否为24。

从4个里选2个的排列有12个，然后计算符又有四种，所以12×4，然后针对这每一种结果，从三个里选2个的排列，是6种，然后计算符也是4种，再乘6×4，最后剩下两个元素，有两个排列，所以再乘2×4.即为上面所说的一共9216种可能。当然这是最多的可能，因为对于乘法和加法计算的二者顺序不影响。

以下为java版本实现，以C++实现同样的思路但就是提示内存超了，没解决。

class Solution {
    public boolean judgePoint24(int[] nums) {
        ArrayList A = new ArrayList<Double>();
        for (int v: nums) A.add((double) v);
        return solve(A);
    }
    private boolean solve(ArrayList<Double> nums) {
        if (nums.size() == 0) return false;
        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<Double>();
                    for (int k = 0; k < nums.size(); k++) if (k != i && k != j) {
                        nums2.add(nums.get(k));
                    }
                    for (int k = 0; k < 4; k++) {
                        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));
                        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;
    }
}

#include<cmath>
class Solution {
public:
    bool judgePoint24(vector<int>& nums) {
      vector<double> num1;
      int l=nums.size();
      for(int i=0;i<l;i++)
      {
          num1.push_back(nums[i]);
      }
      return judge(num1);
    }
    bool judge(vector<double>& nums)
    {
        if(nums.size()==0) return false;
        else if (nums.size()==1)
        {
            if(fabs(nums[0]-24)<0.000001)
                return true;
        }
        else
        {
        for(int i=0;i<nums.size();i++)
        {
            for(int j=0;j<nums.size();j++)
            {
                vector<double> temp;
                if(i!=j)
                {
                     for(int k=0;k<nums.size();k++)
                     {
                         if(k!=i && k!=j)
                         {
                              temp.push_back(nums[k]);
                         }
                     }
                     for(int k=0;k<4;k++)
                     {
                         if(k<2 && j<i) continue;
                         else if(k==0)
                         {
                             temp.push_back(nums[i]+nums[j]);
                         }
                          else if(k==1)
                         {
                             temp.push_back(nums[i]*nums[j]);
                         }
                          else if(k==2)
                         {
                             temp.push_back(nums[i]-nums[j]);
                         }
                          else if(k==3)
                         {
                             if(nums[j]!=0)
                             {
                                temp.push_back(nums[i]/(nums[j]));
                             }
                             else
                                   continue;
                             
                         }
                     }
                     if(judge(temp))
                     {
                         return true;
                     }
                     temp.pop_back();
                }
            }
        }
        }
        return false;
    }
};