单词方程式数字 - C++

单词方程式数字是一种有趣的思维游戏，它要求将每个字母替换成一个数字，使得算式准确。

如何玩

给出一个算式，要求将其中的所有字母替换成某一个数字，使得算式成立。例如，下面的算式

SEND
+ MORE
-------
MONEY

要求将 S、E、N、D、M、O、R、Y 这些字母替换成 0 到 9 中的某个数字，使得算式成立。注意每个字母对应相同的数字，不同的字母对应不同的数字。

题目解法

这是一个搜索问题，每个字母可能替换成 0 到 9 中的某一个数字，可以使用暴力搜索的方式遍历所有可能性，再逐个检查算式是否成立。

代码示例

下面是一个 C++ 实现的例子：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

unordered_set<char> all_chars; // 所有的字母集合
vector<char> chars; // 所有的字母列表
vector<int> nums; // 所有的数字列表
vector<int> mapping(256); // 字符到数字的映射表

bool check(const string& s1, const string& s2, const string& s3) {
    if (s1.size() > 1 && s1[0] == '0') return false; // 首位不能是 0
    if (s2.size() > 1 && s2[0] == '0') return false;
    if (s3.size() > 1 && s3[0] == '0') return false;
    int n1 = 0, n2 = 0, n3 = 0, base = 1;
    for (int i = s1.size() - 1; i >= 0; --i, base *= 10) n1 += mapping[s1[i]] * base;
    for (int i = s2.size() - 1; i >= 0; --i, base *= 10) n2 += mapping[s2[i]] * base;
    for (int i = s3.size() - 1; i >= 0; --i, base *= 10) n3 += mapping[s3[i]] * base;
    return n1 + n2 == n3;
}

void dfs(int i, const string& s1, const string& s2, const string& s3) {
    if (i == chars.size()) {
        if (check(s1, s2, s3)) {
            for (auto c : all_chars) cout << c << "=" << mapping[c] << " ";
            cout << endl;
        }
        return;
    }
    char c = chars[i];
    for (int j = 0; j < nums.size(); ++j) {
        if (nums[j] == -1) continue; // 已经使用过了
        mapping[c] = nums[j]; // 将 c 映射到 nums[j]
        nums[j] = -1; // nums[j] 标记为已使用
        dfs(i + 1, s1, s2, s3);
        nums[j] = mapping[c]; // 恢复状态
        mapping[c] = 0;
    }
}

int main() {
    string s1, s2, s3;
    cin >> s1 >> s2 >> s3;
    for (auto c : s1) all_chars.insert(c);
    for (auto c : s2) all_chars.insert(c);
    for (auto c : s3) all_chars.insert(c);
    for (auto c : all_chars) chars.push_back(c);
    nums.resize(10);
    iota(nums.begin(), nums.end(), 0); // 0 到 9
    do {
        dfs(0, s1, s2, s3);
    } while (next_permutation(nums.begin(), nums.end())); // 遍历所有排列
    return 0;
}

代码实现了一个深度优先搜索，使用了一个映射表来记录字母到数字的映射关系。在搜索的过程中，每层枚举当前字母可以替换的数字，逐个遍历所有可能。如果最后检查算式成立，则输出结果。这个算法的时间复杂度为 $O(10^n \cdot n)$，其中 $n$ 是方程式中不同字母的个数。对于长度比较小且有固定格式的算式，这个算法可以比较快速地得到结果。