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.
解题思路:
例:(4 , 1 , 8 ,7)中的(8 - 4) * ( 7 - 1)
(4 , 1 , 2 , 3) 中的 4 / ( 1 - 2 / 3)
我一直在纠结到底怎么实现(4 8 ) (1 7) 和 (4)(1 2 3) ,如果要区别处理这两种,要通过两种函数,而且非常局限。当数组扩大到3以上的时候,没法确定向量产生的结果是什么。
后来发现一个绝佳的技巧,遍历向量中可能的二元组,再遍历相应二元组所有可能产生的结果,将产生的结果代替二元组,能同时实现上述两种情况,且便于递归处理。
class Solution {
public:
bool judgePoint24(vector<int>& nums)
{
vector<double> num(nums.begin() , nums.end()) ;
return judge(num , ops , 24 , 0.001) ;
}
bool judge(vector<double> nums , vector<char> &ops , int point , double res)
{
if(nums.size() == 1 && abs(nums[0] - point) < res ) return true ;
for(int i = 0 ; i < nums.size() ; i++)
{
for(int j = 0 ; j < nums.size() ; j++)
{
if( i == j) continue ;
vector<double> temp ;
for(int k = 0 ; k < nums.size() ; k++)
{
if(k != i && k != j) temp.push_back(nums[k]) ;
}
for(auto op : ops)
{
if( (op == '+' || op == '*') && i < j ) continue ;
if(op == '/' && nums[j] < res) continue ;
switch(op)
{
case '+':
{
temp.push_back(nums[i] + nums[j]) ;
break ;
}
case '-':
{
temp.push_back(nums[i] - nums[j]) ;
break ;
}
case '*':
{
temp.push_back(nums[i] * nums[j]) ;
break ;
}
case '/':
{
temp.push_back(nums[i] / nums[j]) ;
break ;
}
}
if(judge(temp , ops , point , res)) return true ;
temp.pop_back() ;
}
}
}
return false ;
}
private:
vector<char> ops = {'+' , '-' , '*' , '/'} ;
};
因为分数在内存中是以浮点型存储的,存在误差。所以设置了一个误差范围,只要与point的差的绝对值小于误差范围就可以了。
而且因为除法会产生小数,所以必须用double(float)型的向量存储 。