华为机试HJ89：24点运算

Posted 2021-10-26 翟天保Steven

作者：翟天保Steven
版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处

题目描述：

计算24点是一种扑克牌益智游戏，随机抽出4张扑克牌，通过加(+)，减(-)，乘(*), 除(/)四种运算法则计算得到整数24，本问题中，扑克牌通过如下字符或者字符串表示，其中，小写joker表示小王，大写JOKER表示大王：

3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER

本程序要求实现：输入4张牌，输出一个算式，算式的结果为24点。

详细说明：

1.运算只考虑加减乘除运算，没有阶乘等特殊运算符号，没有括号，友情提醒，整数除法要当心，是属于整除，比如2/3=0，3/2=1；

2.牌面2~10对应的权值为2~10, J、Q、K、A权值分别为为11、12、13、1；

3.输入4张牌为字符串形式，以一个空格隔开，首尾无空格；如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；

4.输出的算式格式为4张牌通过+-*/四个运算符相连，中间无空格，4张牌出现顺序任意，只要结果正确；

5.输出算式的运算顺序从左至右，不包含括号，如1+2+3*4的结果为24，2 A 9 A不能变为(2+1)*(9-1)=24

6.如果存在多种算式都能计算得出24，只需输出一种即可，如果无法得出24，则输出“NONE”表示无解。

7.因为都是扑克牌，不存在单个牌为0的情况，且没有括号运算，除数(即分母)的数字不可能为0

输入描述：

输入4张牌为字符串形式，以一个空格隔开，首尾无空格；

输出描述：

输出怎么运算得到24，如果无法得出24，则输出“NONE”表示无解，如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；

示例：

输入：

4 2 K A

输出：

K-A*4/2

说明：

 A+K*2-4也是一种答案，输出任意一种即可

解题思路：

这题可以用深度优先遍历解决，穷举所有可能出现的情况。首先输入四张牌，用哈希set容器st存储卡牌数量，用dfs进行深度优先遍历；遍历深度达到4结束，表示此时已经4张牌全用上了，若结果为24，则flag设真，中断返回达到提速目的；遍历深度不到4时，通过st进行卡牌数量控制，依次放入path表达式内，且当深度不到3时，遍历运算符，深度到3说明已经放置了4张数字牌了，不需要再加运算符；以此类推，可遍历所有可能的数组和运算符组合，用change函数对JQKA进行数字变形，以便于计算，用cal函数对表达式进行求解，以便于判断是否等于24。

测试代码：

#include <iostream>
#include <string>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>
#include <functional>
#include <stack>
using namespace std;
// 错误码和运算符
unordered_set<string> err {"joker", "JOKER"};
unordered_set<char> pri{'+','-','*','/'};
// 存储每个字符的次数，搜索时用来判断有没有字符可用
unordered_map<string, int> st;
// 结果字符串
string path = "";
// 字符转换数字
int change(char s)    
{
    if (isdigit(s)) return s - '0';
    else if (s == 'A') return 1;
    else if (s == 'J') return 11;
    else if (s == 'Q') return 12;
    else if (s == 'K') return 13;
}
// 计算算术表达式结果
int cal(string path)
{
    stack<int> st;
    stack<char> stc;
    for (int i = 0; i < path.size(); ++i)
    {
        if (!pri.count(path[i]))    //遇到数字
        {
            if (!stc.empty())    //计算
            {
                int a = st.top(); st.pop();
                int c = stc.top(); stc.pop();
                if (c == '+') a += change(path[i]);
                else if (c == '-') a -= change(path[i]);
                else if (c == '*') a *= change(path[i]);
                else a /= change(path[i]);
                st.push(a);    // 中间结果入栈
            }
            else st.push(change(path[i]));    // 之前无运算符，数字入栈
        }
        else stc.push(path[i]);    // 运算符直接入栈
    }
    return st.top();    // 最后栈里的数就是结果
}
// 深度优先遍历
bool dfs(int x)
{
    char div[4] = {'+', '-', '*', '/'};
    bool flag=false;
    if(x==4)
    {
        if (cal(path) == 24) 
        {
            cout << path << endl;
            flag = true;
        }
        return flag;
    }
    for(auto &p:st)
    {
        if (p.second)    // 若字符可用，则加到表达式path中
        {
            p.second--;
            path += p.first;
            if (x != 3)    // x==3时为第四个数字，不需要添加运算符
            {
                for (int i = 0; i < 4; ++i)    //遍历所有运算符
                {
                    path += div[i];
                    flag=dfs(x + 1);
                    if (flag) 
                        return flag;
                    path.pop_back();
                }
            }
            else
                flag=dfs(x + 1);
            if (flag) 
                return flag;
            path.pop_back();
            p.second++;
        }
    }
    return flag;
}
int main()
{
    string a, b, c, d;
    while(cin >> a >> b >> c >> d)
    {
        if (err.count(a) || err.count(b) || err.count(c) || err.count(d))
            cout<<"ERROR"<<endl;
        else
        {
            st[a]++;
            st[b]++;
            st[c]++;
            st[d]++;
            if (!dfs(0)) 
                cout<<"NONE"<<endl;
        }
    }
    return 0;
}