leetcode 679. 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:

  1. The division operator / represents real division, not integer division. For example, 4 / (1 - 2/3) = 12.
  2. 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.
  3. 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)型的向量存储 。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值