题目描述
巴特延斯教授想要训练学生的心算能力,设计了一系列计算结果为 200020002000 的算术问题。但由于打印机故障,所有的运算符(+++、−-−、∗*∗)都没有被打印出来,只留下了数字序列和等号。
我们的任务是:给定一个数字序列,在数字之间插入运算符 +++、−-− 或 ∗*∗,使得表达式的结果等于 200020002000,同时满足以下约束条件:
约束条件
- 必须插入至少一个运算符(不能只是原始数字序列)
- 数字不能有前导零(除了数字 000 本身)
- 只能使用二元运算符 +++、−-−、∗*∗,不能使用单目运算符
- 遵循标准运算优先级(先乘除后加减)
- 输出结果不能重复
输入格式
输入包含多个测试用例,每个测试用例是一行数字序列(长度 1≤n≤91 \leq n \leq 91≤n≤9)后跟等号。最后一个测试用例后是一个单独的等号。
输出格式
对于每个测试用例,输出所有可能的有效表达式,每个表达式缩进 222 个空格。如果没有解,输出 IMPOSSIBLE\texttt{IMPOSSIBLE}IMPOSSIBLE。
题目分析
问题本质
这是一个表达式构造问题,需要在数字序列的所有可能位置插入运算符,生成所有可能的算术表达式,然后验证哪些表达式的结果等于 200020002000。
关键挑战
- 组合爆炸:对于长度为 nnn 的数字序列,有 n−1n-1n−1 个间隙可以插入运算符(或者不插入,即连接数字),每个间隙有 444 种选择(+++、−-−、∗*∗ 或连接),理论上有 4n−14^{n-1}4n−1 种可能组合。
- 运算优先级:需要正确处理 ∗*∗ 优先于 +++ 和 −-− 的运算规则。
- 前导零约束:生成的数字不能有前导零(除了 000 本身)。
解题思路
1. 递归生成所有表达式
使用深度优先搜索(DFS\texttt{DFS}DFS)递归地在每个数字间隙尝试所有可能的操作:
- 连接数字:将当前数字与下一个数字连接形成更大的数字
- 插入运算符:在当前数字后插入 +++、−-− 或 ∗*∗
2. 有效性检查
在生成过程中实时检查:
- 数字有效性:确保没有前导零
- 运算符位置:确保运算符前后都有数字
3. 表达式求值
由于有运算优先级,需要特殊处理:
- 先处理乘法:将连续的乘法运算合并为一个数值
- 再处理加减法:按顺序计算加法和减法
4. 结果去重
使用集合(set\texttt{set}set)自动去除重复的表达式。
算法设计
核心函数
isValidNumber\texttt{isValidNumber}isValidNumber 函数
检查数字字符串是否有效(没有前导零):
bool isValidNumber(const string& num) {
return num.size() == 1 || num[0] != '0';
}
calculate\texttt{calculate}calculate 函数
计算表达式的值,正确处理运算符优先级:
- 先扫描整个表达式,处理所有乘法运算
- 再处理加法和减法运算
hasOperator\texttt{hasOperator}hasOperator 函数
检查表达式是否包含至少一个运算符(题目要求):
bool hasOperator(const vector<string>& tokens) {
for (const string& token : tokens) {
if (token == "+" || token == "-" || token == "*") {
return true;
}
}
return false;
}
generateExpressions\texttt{generateExpressions}generateExpressions 函数
递归生成所有可能的表达式:
- 参数 pos\texttt{pos}pos:当前处理的数字位置
- 参数 current\texttt{current}current:当前已生成的表达式令牌序列
- 参数 currentNum\texttt{currentNum}currentNum:当前正在构建的数字字符串
算法流程
- 读取输入:处理每个测试用例,直到遇到单独的等号
- 递归生成:从第一个数字开始,尝试所有可能的运算符插入方式
- 验证结果:对每个生成的表达式检查是否等于 200020002000
- 输出结果:按格式输出所有有效表达式或 IMPOSSIBLE\texttt{IMPOSSIBLE}IMPOSSIBLE
复杂度分析
- 时间复杂度:O(3n−1×n)O(3^{n-1} \times n)O(3n−1×n),其中 nnn 是数字序列长度
- 空间复杂度:O(n)O(n)O(n),主要用于递归调用栈和存储中间结果
代码实现
// According to Bartjens
// UVa ID: 817
// Verdict: Accepted
// Submission Date: 2025-11-05
// UVa Run Time: 0.520s
//
// 版权所有(C)2025,邱秋。metaphysis # yeah dot net
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <cctype>
using namespace std;
vector<string> results;
string digits;
int n;
// 检查数字是否有效(没有前导零)
bool isValidNumber(const string& num) {
return num.size() == 1 || num[0] != '0';
}
// 计算表达式的值
long long calculate(const vector<string>& tokens) {
// 先处理乘法
vector<long long> values;
vector<char> ops;
long long current = stoll(tokens[0]);
for (int i = 1; i < tokens.size(); i += 2) {
char op = tokens[i][0];
long long next = stoll(tokens[i + 1]);
if (op == '*') {
current *= next;
} else {
values.push_back(current);
ops.push_back(op);
current = next;
}
}
values.push_back(current);
// 处理加法和减法
long long result = values[0];
for (int i = 0; i < ops.size(); i++) {
if (ops[i] == '+') {
result += values[i + 1];
} else {
result -= values[i + 1];
}
}
return result;
}
// 检查是否至少有一个运算符
bool hasOperator(const vector<string>& tokens) {
for (const string& token : tokens) {
if (token == "+" || token == "-" || token == "*") {
return true;
}
}
return false;
}
// 递归生成所有可能的表达式
void generateExpressions(int pos, vector<string>& current, string currentNum) {
if (pos == n) {
if (!isValidNumber(currentNum)) return;
current.push_back(currentNum);
// 必须至少有一个运算符
if (hasOperator(current)) {
// 计算表达式值
if (calculate(current) == 2000) {
string expr;
for (const string& token : current) {
expr += token;
}
expr += "=";
results.push_back(expr);
}
}
current.pop_back();
return;
}
// 情况1:继续延长当前数字(如果没有前导零问题)
if (isValidNumber(currentNum + digits[pos])) {
generateExpressions(pos + 1, current, currentNum + digits[pos]);
}
// 情况2:在当前数字后插入运算符(确保currentNum不为空)
if (!currentNum.empty() && isValidNumber(currentNum)) {
// 尝试 +, -, *
vector<char> operators = {'+', '-', '*'};
for (char op : operators) {
current.push_back(currentNum);
current.push_back(string(1, op));
// 确保运算符后面有数字(从下一个位置开始)
string nextNum = string(1, digits[pos]);
generateExpressions(pos + 1, current, nextNum);
current.pop_back();
current.pop_back();
}
}
}
int main() {
string line;
int caseNum = 1;
while (getline(cin, line) && line != "=") {
// 移除等号及后面的空格
size_t equalPos = line.find('=');
digits = line.substr(0, equalPos);
n = digits.size();
results.clear();
vector<string> current;
generateExpressions(0, current, "");
// 去重
set<string> uniqueResults(results.begin(), results.end());
cout << "Problem " << caseNum++ << endl;
if (uniqueResults.empty()) {
cout << " IMPOSSIBLE" << endl;
} else {
for (const string& result : uniqueResults) {
cout << " " << result << endl;
}
}
}
return 0;
}
总结
这道题考察了递归搜索、表达式求值和约束处理能力。关键点在于:
- 递归生成所有可能的表达式组合
- 正确处理运算优先级
- 严格遵守题目约束条件(前导零、至少一个运算符等)
- 高效去重和结果管理
通过系统的递归搜索和合理的剪枝策略,我们能够在合理的时间内解决这个组合问题。
205



被折叠的 条评论
为什么被折叠?



