24点问题

CSDN编程挑战里的题目

24点游戏是一种使用扑克牌来进行的益智类游戏，游戏内容是：
从一副扑克牌中抽去大小王剩下52张，任意抽取4张牌，把牌面
上的数（A代表1）运用加、减、乘、除和括号进行运算得出24。
每张牌都必须使用一次，但不能重复使用。 有些组合有不同种
算法，例如要用2，4，6，12四张牌组合成24点，可以有如下几
种组合方法：
2 + 4 + 6 + 12 = 24
4 × 6 ÷ 2 + 12 = 24
12 ÷ 4 × (6 + 2) = 24
当然，也有些组合算不出24，如1、1、1、1 和 6、7、8、8等组合.

我的思路是穷举法,将四个数的所有可能运算方式都处理一遍,如果有24则正确.可惜提交了三次才正确,没有获奖的机会了.

我的程序还可以输出其运算的表达式.

#include <stdio.h>
#include <iostream>
#include <string>

#include <cmath>
#include <cfloat>
#include <cstring>
#include <cstdio>

// 4张牌的排列组合
const int g_fourlist[24][4] = 
{
    {0,1,2,3},
    {0,1,3,2},
    {0,2,1,3},
    {0,2,3,1},
    {0,3,2,1},
    {0,3,1,2},

    {1,2,3,0},
    {1,2,0,3},
    {1,3,2,0},
    {1,3,0,2},
    {1,0,2,3},
    {1,0,3,2},

    {2,1,3,0},
    {2,1,0,3},
    {2,3,1,0},
    {2,3,0,1},
    {2,0,1,3},
    {2,0,3,1},

    {3,1,2,0},
    {3,1,0,2},
    {3,2,1,0},
    {3,2,0,1},
    {3,0,1,2},
    {3,0,2,1},
};

void _buildExpress(int a, int b, int c, int d, int n, int i, int j, int k, char* szExpress)
{
    char szN[2] = {0};
    char szI[2] = {0};
    char szJ[2] = {0};
    char szK[2] = {0};

    if (n&1)
    {
        szN[0] = '-';
    }

    switch (i)
    {
    case 0:
        szI[0] = '+';
        break;
    case 1:
        szI[0] = '-';
        break;
    case 2:
        szI[0] = '*';
        break;
    case 3:
        szI[0] = '/';
        break;
    }

    switch (j)
    {
    case 0:
        szJ[0] = '+';
        break;
    case 1:
        szJ[0] = '-';
        break;
    case 2:
        szJ[0] = '*';
        break;
    case 3:
        szJ[0] = '/';
        break;
    }

    switch (k)
    {
    case 0:
        szK[0] = '+';
        break;
    case 1:
        szK[0] = '-';
        break;
    case 2:
        szK[0] = '*';
        break;
    case 3:
        szK[0] = '/';
        break;
    }

    if (n&2)
    {
        sprintf(szExpress, "%s%d %s %d %s (%d %s %d) == 24", szN, a, szI, b, szJ, c, szK, d);
    }
    else
    {
        sprintf(szExpress, "%s%d %s %d %s %d %s %d == 24", szN, a, szI, b, szJ, c, szK, d);
    }
}

/*
表达式的组合有以下四类:
a?b?c?d
(-a)?b?c?d)
(a?b) ? (c?d)
((-a)?b) ? (c?d))
表达式从左向右计算,
+,-,*,/无优先级顺序

6/(1-(3/4))
*/

bool _can24(int a, int b, int c, int d, char* szExpress)
{
    float valueA;
    float valueAB;
    float valueABC;
    float valueCD;
    float valueABCD;

    for (int n = 0; n < 4; n++)
    {
        valueA = (n&1) ? -(float)a : (float)a;

        for (int i = 0; i < 4; i++)
        {
            switch (i)
            {
            case 0:
                valueAB = valueA+b;
                break;
            case 1:
                valueAB = valueA-b;
                break;
            case 2:
                valueAB = valueA*b;
                break;
            case 3:
                valueAB = valueA/b;
                break;
            }

            if (n&2)
            {
                // (a?b) ? (c?d)
                for (int k = 0; k < 4; k++)
                {
                    switch (k)
                    {
                    case 0:
                        valueCD = (float)c+d;
                        break;
                    case 1:
                        valueCD = (float)c-d;
                        break;
                    case 2:
                        valueCD = (float)c*d;
                        break;
                    case 3:
                        valueCD = (float)c/d;
                        break;
                    }

                    for (int j = 0; j < 4; j++)
                    {
                        switch (j)
                        {
                        case 0:
                            valueABCD = valueAB+valueCD;
                            break;
                        case 1:
                            valueABCD = valueAB-valueCD;
                            break;
                        case 2:
                            valueABCD = valueAB*valueCD;
                            break;
                        case 3:
                            valueABCD = valueAB/valueCD;
                            break;
                        }

                        if (fabs(valueABCD - 24) < FLT_EPSILON)
                        {
                            if (szExpress)
                            {
                                _buildExpress(a, b, c, d, n, i, j, k, szExpress);
                            }
                            return true;
                        }
                    }
                }
            }
            else
            {
                for (int j = 0; j < 4; j++)
                {
                    switch (j)
                    {
                    case 0:
                        valueABC = valueAB+c;
                        break;
                    case 1:
                        valueABC = valueAB-c;
                        break;
                    case 2:
                        valueABC = valueAB*c;
                        break;
                    case 3:
                        valueABC = valueAB/c;
                        break;
                    }

                    for (int k = 0; k < 4; k++)
                    {
                        switch (k)
                        {
                        case 0:
                            valueABCD = valueABC+d;
                            break;
                        case 1:
                            valueABCD = valueABC-d;
                            break;
                        case 2:
                            valueABCD = valueABC*d;
                            break;
                        case 3:
                            valueABCD = valueABC/d;
                            break;
                        }

                        if (fabs(valueABCD - 24) < FLT_EPSILON)
                        {
                            if (szExpress)
                            {
                                _buildExpress(a, b, c, d, n, i, j, k, szExpress);
                            }
                            return true;
                        }
                        else if (fabs(valueABCD - 1.0f/24) < FLT_EPSILON)
                        {
                            // 1/24也可以
                            if (szExpress)
                            {
                                _buildExpress(a, b, c, d, n, i, j, k, szExpress);
                            }
                            return true;
                        }
                    }
                }
            }
        }
    }

    return false;
}

bool Can24(const int four[4], char* szExpress)
{
    for (int i = 0; i < 24; i++)
    {
        if (_can24(four[g_fourlist[i][0]], 
                   four[g_fourlist[i][1]],
                   four[g_fourlist[i][2]],
                   four[g_fourlist[i][3]],
                   szExpress))
        {
            return true;
        }
    }

    return false;
}