用c++的剪枝算法写一个人机对弈的五子棋算法

好的，这里是一个用 C++ 实现的五子棋 AI，使用了 Alpha-Beta 剪枝算法：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int BOARD_SIZE = 15; // 棋盘大小
const int MAX_DEPTH = 3; // 最大搜索深度
const int WIN_SCORE = 1000000; // 获胜得分
const int INF = 0x3f3f3f3f; // 无穷大

int board[BOARD_SIZE][BOARD_SIZE]; // 棋盘
int player; // 玩家
int ai; // AI

// 判断是否越界
bool isInRange(int x, int y) {
    return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE;
}

// 判断是否为空位
bool isEmpty(int x, int y) {
    return board[x][y] == 0;
}

// 判断是否为玩家棋子
bool isPlayer(int x, int y) {
    return board[x][y] == player;
}

// 判断是否为 AI 棋子
bool isAI(int x, int y) {
    return board[x][y] == ai;
}

// 在 (x,y) 处落子
void move(int x, int y, int chess) {
    board[x][y] = chess;
}

// 悔棋
void unmove(int x, int y) {
    board[x][y] = 0;
}

// 检查是否五子连珠
bool checkWin(int x, int y) {
    int dx[4] = {0, 1, 1, 1}; // 横、竖、斜1、斜2
    int dy[4] = {1, 0, 1, -1};
    for(int i = 0; i < 4; i++) {
        int cnt = 1;
        for(int j = 1; j <= 4; j++) {
            int nx = x + j * dx[i], ny = y + j * dy[i];
            if(isInRange(nx, ny) && isAI(nx, ny)) cnt++;
            else break;
        }
        for(int j = 1; j <= 4; j++) {
            int nx = x - j * dx[i], ny = y - j * dy[i];
            if(isInRange(nx, ny) && isAI(nx, ny)) cnt++;
            else break;
        }
        if(cnt >= 5) return true;
    }
    return false;
}

// 评估函数
int evaluate() {
    int score = 0;
    // 统计每个空位的得分
    for(int i = 0; i < BOARD_SIZE; i++) {
        for(int j = 0; j < BOARD_SIZE; j++) {
            if(isEmpty(i, j)) {
                int cnt1 = 0, cnt2 = 0;
                int dx[4] = {0, 1, 1, 1}; // 横、竖、斜1、斜2
                int dy[4] = {1, 0, 1, -1};
                for(int k = 0; k < 4; k++) {
                    int cnt = 1;
                    for(int l = 1; l <= 4; l++) {
                        int nx = i + l * dx[k], ny = j + l * dy[k];
                        if(isInRange(nx, ny) && isAI(nx, ny)) cnt++;
                        else break;
                    }
                    for(int l = 1; l <= 4; l++) {
                        int nx = i - l * dx[k], ny = j - l * dy[k];
                        if(isInRange(nx, ny) && isAI(nx, ny)) cnt++;
                        else break;
                    }
                    if(cnt >= 5) cnt1++;
                    else if(cnt == 4) cnt2++;
                }
                score += cnt1 * WIN_SCORE + cnt2 * (WIN_SCORE / 10);
            }
        }
    }
    return score;
}

// Alpha-Beta 剪枝搜索
int alphabeta(int depth, int alpha, int beta) {
    if(depth == 0) return evaluate(); // 叶节点，返回评估值
    vector<pair<int, int>> moves; // 当前局面下所有可行的落子位置
    for(int i = 0; i < BOARD_SIZE; i++) {
        for(int j = 0; j < BOARD_SIZE; j++) {
            if(isEmpty(i, j)) moves.push_back({i, j});
        }
    }
    if(moves.empty()) return 0; // 没有可行的落子位置，返回 0
    // 对可行的落子位置进行排序，以加速剪枝
    sort(moves.begin(), moves.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
        return evaluate() > evaluate();
    });
    int bestScore = -INF; // 最佳得分
    for(const auto& move : moves) {
        int x = move.first, y = move.second;
        move(x, y, ai); // AI 落子
        int score = -alphabeta(depth - 1, -beta, -alpha); // 对手的最佳反应是当前局面的最大负值
        unmove(x, y); // 悔棋
        if(score >= beta) return score; // Beta 剪枝
        if(score > bestScore) { // 更新最佳得分和 Alpha 值
            bestScore = score;
            if(score > alpha) alpha = score;
        }
    }
    return bestScore;
}

// AI 落子
void AIMove() {
    vector<pair<int, int>> moves; // 当前局面下所有可行的落子位置
    for(int i = 0; i < BOARD_SIZE; i++) {
        for(int j = 0; j < BOARD_SIZE; j++) {
            if(isEmpty(i, j)) moves.push_back({i, j});
        }
    }
    if(moves.empty()) return; // 没有可行的落子位置，直接返回
    int bestScore = -INF; // 最佳得分
    pair<int, int> bestMove; // 最佳落子位置
    // 对可行的落子位置进行排序，以加速搜索
    sort(moves.begin(), moves.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
        return evaluate() > evaluate();
    });
    // 搜索最佳落子位置
    for(const auto& move : moves) {
        int x = move.first, y = move.second;
        move(x, y, ai); // AI 落子
        int score = -alphabeta(MAX_DEPTH - 1, -INF, INF); // 对手的最佳反应是当前局面的最大负值
        unmove(x, y); // 悔棋
        if(score > bestScore) { // 更新最佳得分和最佳落子位置
            bestScore = score;
            bestMove = move;
        }
    }
    move(bestMove.first, bestMove.second, ai); // AI 落子
    cout << "AI moves: (" << bestMove.first << ", " << bestMove.second << ")" << endl;
}

// 玩家落子
void playerMove() {
    int x, y;
    while(true) {
        cout << "Please enter your move (x y): ";
        cin >> x >> y;
        if(isInRange(x, y) && isEmpty(x, y)) break;
        else cout << "Invalid move, please try again." << endl;
    }
    move(x, y, player); // 玩家落子
}

// 打印棋盘
void printBoard() {
    cout << "  ";
    for(int i = 0; i < BOARD_SIZE; i++) {
        cout << i << " ";
    }
    cout << endl;
    for(int i = 0; i < BOARD_SIZE; i++) {
        cout << i << " ";
        for(int j = 0; j < BOARD_SIZE; j++) {
            if(isEmpty(i, j)) cout << "+ ";
            else if(isPlayer(i, j)) cout << "O ";
            else cout << "X ";
        }
        cout << endl;
    }
}

int main() {
    // 初始化
    for(int i = 0; i < BOARD_SIZE; i++) {
        for(int j = 0; j < BOARD_SIZE; j++) {
            board[i][j] = 0;
        }
    }
    player = 1;
    ai = 2;
    // 开始游戏
    while(true) {
        printBoard();
        playerMove();
        if(checkWin(player)) {
            cout << "You win!" << endl;
            break;
        }
        AIMove();
        if(checkWin(ai)) {
            cout << "AI wins!" << endl;
            break;
        }
    }
    return 0;
}

这个五子棋 AI 使用 Alpha-Beta 剪枝算法进行搜索，评估函数采用了一种简单的方法，即统计每个空位的得分，得分越高的空位越有可能是最佳落子位置。这个 AI 的搜索深度可以通过修改 `MAX_DEPTH` 来调整，可以根据自己的需求进行调整。