题解 | #24点运算#

#include <iostream>
#include <sstream>
using namespace std;
#include <string>
#include <vector>

int str2num(string str) {
    int result = -1;
    if (str == "joker" || str == "JOKER") {
        return -1;
    }
    if (str == "10") {
        return 10;
    }
    if (str[0] >= '2' && str[0] <= '9') {
        result = str[0] - '0';
    } else {
        if (str[0] == 'J') {
            result = 11;
        } else if (str[0] == 'Q') {
            result = 12;
        } else if (str[0] == 'K') {
            result = 13;
        } else if (str[0] == 'A') {
            result = 1;
        }
    }
    return result;
}

bool dfs(const vector<int>& nums, vector<char> caculate, vector<char>& res,
         int num, vector<bool> numUsed, vector<int> resNum, vector<int>& res2) {
    if (num == 24 && numUsed[0] && numUsed[1] && numUsed[2] && numUsed[3]) {
        res = caculate;
        res2 = resNum;
        return true;
    } else if (num != 24 && numUsed[0] && numUsed[1] && numUsed[2] && numUsed[3]) {
        return false;
    } else {
        for (int k = 0; k < 4; k++) {
            if (numUsed[k] == false) {
                numUsed[k] = true;
                resNum.push_back(nums[k]);
                for (int j = 0; j <= 3; j++) {
                    switch (j) {
                        case 0:
                            caculate.push_back('+');
                            if (dfs(nums, caculate, res, num + nums[k], numUsed, resNum, res2)) {
                                return true;
                            }
                            caculate.pop_back();
                            break;
                        case 1:
                            caculate.push_back('-');
                            if (dfs(nums, caculate, res, num - nums[k], numUsed, resNum, res2)) {
                                return true;
                            }
                            caculate.pop_back();
                            break;
                        case 2:
                            caculate.push_back('*');
                            if (dfs(nums, caculate, res, num * nums[k], numUsed, resNum, res2)) {
                                return true;
                            }
                            caculate.pop_back();
                            break;
                        case 3:
                            caculate.push_back('/');
                            if (dfs(nums, caculate, res, num / nums[k], numUsed, resNum, res2)) {
                                return true;
                            }
                            caculate.pop_back();
                            break;
                    }
                }
                numUsed[k] = false;
                resNum.pop_back();
            }
        }
    }
    return false;
}

int main() {
    string str;
    getline(cin, str);
    istringstream is(str);
    string word;
    vector<int> nums;
    bool noJoker = true;
    while (is >> word) {
        if (str2num(word) == -1) {
            noJoker = false;
        }
        nums.push_back(str2num(word));
    }
    vector<char> caculate;
    vector<char> res;
    vector<int> resNum;
    vector<int> res2;
    vector<bool> used(4, false);
    bool flag = false;
    if (noJoker) {
        for (int i = 0; i < 4; i++) {
            used[i] = true;
            resNum.push_back(nums[i]);
            if (dfs(nums, caculate, res, nums[i], used, resNum, res2)) {
                flag = true;
            }
            resNum.pop_back();
            used[i] = false;
        }
        if (flag) {
            for (auto& x : res2) {
                if (x >= 2 && x <= 10) {
                    cout << x;
                } else {
                    switch (x) {
                        case 1:
                            cout << "A";
                            break;
                        case 11:
                            cout << "J";
                            break;
                        case 12:
                            cout << "Q";
                            break;
                        case 13:
                            cout << "K";
                            break;
                    }
                }
                if (!res.empty()) {
                    cout << *res.begin();
                    res.erase(res.begin());
                }
            }
        } else {
            cout << "NONE" << endl;
        }
    } else {
        cout << "ERROR" << endl;
    }
}

与HJ67的解法几乎一致，只不过要存储结果数据且触发是整数除法

有个坑，它虽然讲“没有括号”，但是计算元素的位置可以调换，所以依然需要遍历全排列