真的很好用，试了三局，全都好用！！！

只支持9*9。

#include<bits/stdc++.h>
using namespace std;

// 定义棋盘大小
const int N = 9;

// 八个方向移动的偏移量，用于邻居格子的判断
int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};

// 用于存储当前的9x9棋盘
vector<vector<int>> board(N, vector<int>(N));

// 用于枚举雷的位置
vector<pair<int, int>> unknowns;

// 存储所有有效的雷布局
vector<vector<vector<int>>> validLayouts;

// 检查当前雷布局是否符合已知数字的提示
bool isValidLayout(vector<vector<int>>& mines) {
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (board[i][j] >= 0) { // 如果该格子是数字
                int count = 0;
                // 计算周围的雷数
                for (int k = 0; k < 8; ++k) {
                    int ni = i + dx[k];
                    int nj = j + dy[k];
                    if (ni >= 0 && ni < N && nj >= 0 && nj < N && mines[ni][nj] == 1) {
                        count++;
                    }
                }
                // 如果周围雷的数量不符合数字提示，返回 false
                if (count != board[i][j]) {
                    return false;
                }
            }
        }
    }
    return true;
}

// 枚举所有可能的雷布局
void enumerateMines(int idx, vector<vector<int>>& mines) {
    if (idx == unknowns.size()) {
        // 当所有未知格子都被处理完时，检查当前雷布局是否有效
        if (isValidLayout(mines)) {
            validLayouts.push_back(mines);
        }
        return;
    }

    // 当前要处理的未知格子的坐标
    int x = unknowns[idx].first;
    int y = unknowns[idx].second;

    // 假设这个格子是雷
    mines[x][y] = 1;
    enumerateMines(idx + 1, mines);

    // 假设这个格子不是雷
    mines[x][y] = 0;
    enumerateMines(idx + 1, mines);
}

// 绘制所有可能雷的叠加图像
void drawCombinedLayouts() {
    vector<vector<int>> combined(N, vector<int>(N, 0));

    // 对所有有效布局进行累加
    for (const auto& layout : validLayouts) {
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                combined[i][j] += layout[i][j];
            }
        }
    }

    // 输出合并后的雷布局
    cout << "所有可能雷的布局叠加图：" << endl;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (board[i][j] >= 0) {
                cout << board[i][j] << " ";  // 显示已知的数字
            } else if (combined[i][j] == validLayouts.size()) {
                cout << "* ";  // 如果某个格子在所有布局中都是雷，显示雷
            } else if (combined[i][j] == 0) {
                cout << ". ";  // 如果某个格子在所有布局中都不是雷，显示安全区域
            } else {
                cout << "? ";  // 如果某个格子在不同布局中有雷也可能没有雷，用 '?' 表示
            }
        }
        cout << endl;
    }
}

int main() {
    cout << "请输入当前9x9棋盘的局势，每个格子输入一个数字（0表示安全区，-1表示未知区域）：" << endl;

    // 输入棋盘状态
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            cin >> board[i][j];
            if (board[i][j] == -1) {
                // 记录所有未知的格子坐标
                unknowns.push_back({i, j});
            }
        }
    }

    // 用于存储当前雷布局，0表示安全，1表示雷
    vector<vector<int>> mines(N, vector<int>(N, 0));

    cout << "开始枚举所有可能的雷布局(需要一段时间)..." << endl;
    enumerateMines(0, mines);

    // 绘制所有可能雷的布局
    drawCombinedLayouts();

    return 0;
}