使用C++写一个反四子棋的bot

反四子棋是一种象棋变种，它的规则与象棋基本相同，但是在落子时有一个限制：如果你的落子会使对方下一步将军，则你不能落这个子。在这里，我提供一个简单的反四子棋bot的C++代码实现，供参考。

首先，我们需要定义一个棋盘类，它包含了存储棋盘状态的变量和一些基本操作，如落子、判断是否胜利等。

#include <iostream>
#include <cstring>
using namespace std;

// 定义棋盘大小
const int BOARD_SIZE = 10;

// 棋盘类
class Board {
public:
    // 构造函数
    Board() {
        memset(board, 0, sizeof(board)); // 初始化棋盘为空
    }

    // 落子操作，返回是否合法
    bool drop(int x, int y, int player) {
        if (board[x][y] != 0) {
            return false; // 该位置已有棋子
        }
        board[x][y] = player; // 落子
        return true;
    }

    // 判断某个玩家是否胜利
    bool win(int player) {
        // 判断横向连续棋子
        for (int i = 0; i < BOARD_SIZE; i++) {
            int count = 0;
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }

        // 判断纵向连续棋子
        for (int j = 0; j < BOARD_SIZE; j++) {
            int count = 0;
            for (int i = 0; i < BOARD_SIZE; i++) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }

        // 判断主对角线连续棋子
        for (int k = 0; k < BOARD_SIZE; k++) {
            int count = 0;
            for (int i = k, j = 0; i < BOARD_SIZE && j < BOARD_SIZE; i++, j++) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }
        for (int k = 1; k < BOARD_SIZE; k++) {
            int count = 0;
            for (int i = 0, j = k; i < BOARD_SIZE && j < BOARD_SIZE; i++, j++) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }

        // 判断副对角线连续棋子
        for (int k = 0; k < BOARD_SIZE; k++) {
            int count = 0;
            for (int i = k, j = BOARD_SIZE - 1; i < BOARD_SIZE && j >= 0; i++, j--) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }
        for (int k = BOARD_SIZE - 2; k >= 0; k--) {
            int count = 0;
            for (int i = 0, j = k; i < BOARD_SIZE && j >= 0; i++, j--) {
                if (board[i][j] == player) {
                    count++;
                } else {
                    count = 0;
                }
                if (count >= 5) {
                    return true;
                }
            }
        }

        return false;
    }

    // 打印棋盘
    void print() {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                cout << board[i][j] << " ";
            }
            cout << endl;
        }
    }

private:
    int board[BOARD_SIZE][BOARD_SIZE]; // 存储棋盘状态
};

接下来，我们需要定义一个反四子棋bot类，它包含了搜索最佳落子位置的算法和一些辅助函数。

// 反四子棋bot类
class Bot {
public:
    // 构造函数
    Bot(Board& board, int player) : board(board), player(player) {}

    // 搜索最佳落子位置
    void search(int& x, int& y) {
        int score[BOARD_SIZE][BOARD_SIZE]; // 存储每个位置的分数
        memset(score, 0, sizeof(score)); // 初始化分数为0

        // 遍历每个空位置
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board.drop(i, j, player)) {
                    // 计算该位置的分数
                    score[i][j] = evaluate(player);

                    // 模拟对方落子，并计算对方最佳落子位置的分数
                    int opp_x, opp_y;
                    int opp_score = 0;
                    for (int ii = 0; ii < BOARD_SIZE; ii++) {
                        for (int jj = 0; jj < BOARD_SIZE; jj++) {
                            if (board.drop(ii, jj, 3 - player)) {
                                int s = evaluate(3 - player);
                                if (s > opp_score) {
                                    opp_score = s;
                                    opp_x = ii;
                                    opp_y = jj;
                                }
                                board.drop(ii, jj, 0);
                            }
                        }
                    }

                    // 减去对方最佳落子位置的分数
                    score[i][j] -= opp_score;

                    // 恢复棋盘状态
                    board.drop(i, j, 0);
                }
            }
        }

        // 找到分数最高的位置
        int max_score = -1;
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (score[i][j] > max_score) {
                    max_score = score[i][j];
                    x = i;
                    y = j;
                }
            }
        }
    }

private:
    Board& board; // 棋盘引用
    int player; // 玩家编号

    // 评估棋局的分数
    int evaluate(int player) {
        int score = 0;

        // 判断横向连续棋子
        for (int i = 0; i < BOARD_SIZE; i++) {
            int count = 0;
            int empty = 0;
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }

        // 判断纵向连续棋子
        for (int j = 0; j < BOARD_SIZE; j++) {
            int count = 0;
            int empty = 0;
            for (int i = 0; i < BOARD_SIZE; i++) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }

        // 判断主对角线连续棋子
        for (int k = 0; k < BOARD_SIZE; k++) {
            int count = 0;
            int empty = 0;
            for (int i = k, j = 0; i < BOARD_SIZE && j < BOARD_SIZE; i++, j++) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }
        for (int k = 1; k < BOARD_SIZE; k++) {
            int count = 0;
            int empty = 0;
            for (int i = 0, j = k; i < BOARD_SIZE && j < BOARD_SIZE; i++, j++) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }

        // 判断副对角线连续棋子
        for (int k = 0; k < BOARD_SIZE; k++) {
            int count = 0;
            int empty = 0;
            for (int i = k, j = BOARD_SIZE - 1; i < BOARD_SIZE && j >= 0; i++, j--) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }
        for (int k = BOARD_SIZE - 2; k >= 0; k--) {
            int count = 0;
            int empty = 0;
            for (int i = 0, j = k; i < BOARD_SIZE && j >= 0; i++, j--) {
                if (board.drop(i, j, player)) {
                    count++;
                } else if (board.drop(i, j, 0)) {
                    empty++;
                } else {
                    count = 0;
                    empty = 0;
                }
                if (count >= 4 && empty >= 1) {
                    score += 1000;
                } else if (count >= 3 && empty >= 2) {
                    score += 100;
                } else if (count >= 2 && empty >= 3) {
                    score += 10;
                } else if (count >= 1 && empty >= 4) {
                    score += 1;
                }
                board.drop(i, j, 0);
            }
        }

        return score;
    }
};

最后，我们可以编写一个简单的主函数来测试反四子棋bot的功能。

int main() {
    Board board; // 创建棋盘
    Bot bot(board, 1); // 创建bot

    // 玩家轮流落子，直到有一方胜利
    while (true) {
        int x, y;
        board.print();
        cout << "Player 1's turn:" << endl;
        cout << "Enter the row and column number:" << endl;
        cin >> x >> y;
        while (!board.drop(x, y, 1)) {
            cout << "Invalid move! Enter the row and column number again:" << endl;
            cin >> x >> y;
        }
        if (board.win(1)) {
            board.print();
            cout << "Player 1 wins!" << endl;
            break;
        }

        bot.search(x, y); // bot搜索最佳落子位置
        board.drop(x, y, 2); // bot落子
        cout << "Bot's move: row " << x << ", column " << y << endl;
        if (board.win(2)) {
            board.print();
            cout << "Bot wins!" << endl;
            break;
        }
    }

    return 0;
}

这样，我们就完成了一个简单的反四子棋bot的C++代码实现。当然，这只是一个基础版的bot，如果要提高它的水平，可以考虑使用更高级的算法，如蒙特卡罗树搜索、神经网络等。