数字表达式 According to Bartjens

最新推荐文章于 2025-12-22 09:47:08 发布

原创最新推荐文章于 2025-12-22 09:47:08 发布 · 491 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #深度优先

文章讲述了如何通过DFS遍历和逆波兰表示法处理带有符号的表达式，避免前导零并考虑运算符优先级，以求得正确结果。

本题只知道至少添加一个符号，所以我们需要依次枚举添加一个、两个、三个一直到 $n - 2$ 个（ $n$ 为表达式的长度），然后使用 DFS 尝试在每个位置放置符号，放置的时候需要注意不能出现含有前导零的数字，保证不出现前导零有两种方案：

枚举所有位置，在最后进行检查的时候判断出现在计算符号之后的数字以 $0$ 开头但是位数大于 $1$ ；
在搜索的过程中进行判断，假定搜索到位置 $p os$ 如果当前位置是 $0$ 那么当前位置的后面只能放置非数字符号；

如何计算表达式的值？可以使用逆波兰表达式，具体的使用两个栈，一个用来保存数字，一个用来保存符号，符号站里面的符号的优先级要保证递增：

遇到数字则直接加入数字栈；
遇到符号的时候，检查符号与符号栈栈顶的符号的优先级，如果栈顶的符号优先级较高或相等，那么则应该弹出栈顶的符号进行一次计算，直到符号栈为空，或者栈顶的符号优先级较低，再将当前的符号入栈；
最后弹出符号栈里面的所有符号依次进行计算。

Code:

#include <bits/stdc++.h>

const int NaN = 0x3f3f3f3f;
const int OPERATOR_NUM = 3;

using namespace std;

int maxDepth, caseID;
string expression, now;
char ope[] = "*+-";
vector<string> ans;

// 比较两个运算符的优先级
int cmp(char op1, char op2)
{
    if (op1 == op2) { return 0; }
    if (op1 == '*') { return 1; }
    if (op2 == '*') { return -1; }
    return 0;
}

// 计算两个数的和、差或者积
int calculate(int lhs, char ope, int rhs)
{
    if (ope == '+') { return lhs + rhs; }
    if (ope == '-') { return lhs - rhs; }
    return lhs * rhs;
}

bool check()
{
    int num = NaN, lhs = 0, rhs = 0;
    stack<int> number;
    stack<char> ops;
    for (int i = 0; i < now.length() - 1; i++) {
        if (isdigit(now[i])) {
            if (num == NaN) { num = 0; }
            num = num * 10 + now[i] - '0';
        } else {
            number.push(num);
            while (!ops.empty() && cmp(ops.top(), now[i]) >= 0) {
                rhs = number.top(); number.pop();
                lhs = number.top(); number.pop();
                number.push(calculate(lhs, ops.top(), rhs));
                ops.pop();
            }
            ops.push(now[i]);
            num = NaN;
        }
    }
    if (num != NaN) { number.push(num); }
    while (!ops.empty()) {
        rhs = number.top(); number.pop();
        lhs = number.top(); number.pop();
        num = calculate(lhs, ops.top(), rhs); ops.pop();
        number.push(num);
    }
    return number.top() == 2000;
}

void dfs(int nowDepth, int pos)
{
    if (nowDepth == maxDepth) {
        int tempLen = now.length();
        int increment = expression.length() - pos;
        now.append(expression.substr(pos, increment));
        if (check()) { ans.push_back(now); }
        now.erase(tempLen, increment);
        return;
    }
    if (maxDepth - nowDepth > expression.length() - 2 - pos) { return; }
    for (int i = pos; i < expression.length() - 2; i++) {
    	// 这里是保证最后一个数字不含有前导零
        if (nowDepth == maxDepth - 1 && expression[i + 1] == '0' && expression[i + 2] != '=') { continue; }
        for (int j = 0; j < OPERATOR_NUM; j++) {
            int tempLen = now.length();
            int increment = i - pos + 1 + 1;
            now.append(expression.substr(pos, i - pos + 1));
            now.push_back(ope[j]);
            dfs(nowDepth + 1, i + 1);
            now.erase(tempLen, increment);
        }
        // 这里保证当前数字不含前导零，当前数字如果是以0开头那么不能继续进行拼接
        if (expression[pos] == '0') { break; }
    }
}

int main()
{
    while (cin >> expression) {
        ans.resize(0);
        now = "";
        if (expression[0] == '=') { break; }
        for (maxDepth = 1; maxDepth < expression.length() - 1; maxDepth++) { dfs(0, 0); }
        caseID++;
        cout << "Problem " << caseID << endl;
        sort(ans.begin(), ans.end());
        for (auto str : ans) { cout << "  " << str << endl; }
        if (ans.size() == 0) { cout << "  IMPOSSIBLE" << endl; }
    }
    return 0;
}