计算24点

题目参考链接:杭电1427   http://acm.hdu.edu.cn/showproblem.php?pid=1427

在自行编写的暴力枚举代码TLE之后,在网上搜索了一下,得到如下简化后的暴力求解思路。

先将给你的4个数进行全排列,在这过程中,对每一个全排列去进行判断,看这种排列是否能用四则运算算出24点。若算出24点,便输出“Yes”。对于其中某一种排列a,b,c,d,设#为任意一种四则运算,则仅需讨论以下两种情况,即考虑了所有可能的运算结果。
1. (a#b)#(c#d)
2. ((a#b)#c)#d
注意:在这种简化的情形下,-24也是可以的。可参考: 链接一:代码参考链接二:思路简化链接三:考虑-24。而在 链接四:简短代码版中,作者通过algorithm里的next_permutation枚举给定数组的所有排列,从而大大简化了代码。
其中next_permutation的用法参见 C++文档,有关其实现的讨论参见 stackoverflow的讨论

整合上述信息,在杭电1427上AC的参考代码如下:

#include <iostream>
using namespace std;
 
const int INF = 1 << 30;
 
int a[4];
int res[4];
bool vis[4];
bool flag;
 
 
int deal(int x,int y,int i)  //四则运算
{
    switch(i)
    {
    case 0 : return x + y;
    case 1 : return x - y;
    case 2 : return x * y;
    case 3 : if(y != 0 && x % y == 0) return x / y;else return INF;
    }
}
 
bool can()        //判断该种排列运用四则运算是否能算出
{
    int i,j,k;
    int t1,t2,t3;
    for(i = 0;i < 4;i ++)         //(a @ b) @ (c @ d)
    {
        t1 = deal(res[0],res[1],i);
        if(t1 == INF) continue;
        for(j = 0;j < 4;j ++)
        {
            t2 = deal(res[2],res[3],j);
            if(t2 == INF) continue;
            for(k = 0;k < 4;k ++)
            {
                t3 = deal(t1,t2,k);
                if(t3 == 24 || t3 == -24) return 1;
            }
        }
    }
    for(i = 0;i < 4;i ++)     //((a @ b) @ c) @ d
    {
        t1 = deal(res[0],res[1],i);
        if(t1 == INF) continue;
        for(j = 0;j < 4;j ++)
        {
            t2 = deal(t1,res[2],j);
            if(t2 == INF) continue;
            for(k = 0;k < 4;k ++)
            {
                t3 = deal(t2,res[3],k);
                if(t3 == 24 || t3 == -24) return 1;
            }
        }
    }
    return 0;    //都不能算出,说明无解
}
 
void dfs(int p)    //全排列
{
    if(p == 4)
    {
        if(can()) flag = 1;
        return;
    }
    int i,j;
    for(i = 0;i < 4;i ++)
    {
        if(!vis[i]) 
        {
            res[p] = a[i];
            vis[i] = 1;
            dfs(p + 1);
            if(flag) return;
            vis[i] = 0;
        }
    }
}
 
int main()
{
    char s[3];
    int i,j,k;
    while(1)
    {
        for(i = 0;i < 4;i ++)
        {
            if(scanf("%s",s) == EOF) return 0;
            if(s[0] == 'A') a[i] = 1;
            else if(s[0] == 'J') a[i] = 11;
            else if(s[0] == 'Q') a[i] = 12;
            else if(s[0] == 'K') a[i] = 13;
            else if(s[0] == '1' && s[1] == '0') a[i] = 10; 
            else a[i] = s[0] - '0';
        }
        flag = 0;
        memset(vis,0,sizeof(vis));
        dfs(0);
        if(flag) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算二十四点是一个经典的扑克牌游戏,玩家需要通过运算使得手中的四张牌的运算结果为24。在Java中,我们可以使用递归方法实现这个计算过程。 首先,我们需要定义一个递归函数,该函数的输入参数是一个存储扑克牌数字的数组和一个表示运算结果是否为24的布尔值。在每一轮递归中,我们会对数组中的所有可能的数字组合进行计算,并将计算结果递归传递给下一层。 在计算结果为24的情况下,我们会将布尔值设为true,并在递归结束后返回该值。如果递归过程中没有找到计算结果为24的情况,布尔值会保持为false,最终返回该值。 具体的计算逻辑如下: 1. 首先定义一个函数,接收一个数组和一个布尔值作为参数。 2. 如果数组长度为1且该数字等于24,则返回true。 3. 对于数组中的每个数字,我们选择其中两个数字进行四则运算,并将结果存储在一个新的数组中。 4. 递归调用该函数,将新数组和布尔值作为参数传递。 5. 如果递归函数返回true,则表示找到了计算结果为24的情况,直接返回true。 6. 对于每一对数字的四则运算,我们都需要进行加法、减法、乘法和除法运算,并将得到的结果进行递归计算。 7. 如果在该函数的任何运算过程中找到了计算结果为24的情况,直接返回true。 8. 如果以上步骤中都没有找到计算结果为24的情况,则返回false。 通过以上递归方法,我们可以在Java中完成扑克牌计算二十四点的游戏。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值