用C++代码写一个六子棋对弈自走程序

六子棋对弈自走程序的实现需要以下几个步骤：

1. 定义棋盘数据结构和棋子枚举类型；
2. 实现棋盘初始化函数、落子函数和判断胜负函数；
3. 实现 AI 算法，即在当前棋盘状态下，计算出最优的落子位置；
4. 实现游戏循环，让 AI 和玩家轮流落子，直到有一方获胜或出现平局。

下面是用 C 代码实现六子棋对弈自走程序的示例：

#include <stdio.h>

#define ROWS 15
#define COLS 15
#define WIN_NUM 6

enum Chess {
    EMPTY,
    BLACK,
    WHITE
};

struct ChessBoard {
    enum Chess data[ROWS][COLS];
};

void init_board(struct ChessBoard* board) {
    int i, j;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            board->data[i][j] = EMPTY;
        }
    }
}

void print_board(struct ChessBoard* board) {
    int i, j;
    printf("  ");
    for (j = 0; j < COLS; j++) {
        printf("%d ", j + 1);
    }
    printf("\n");
    for (i = 0; i < ROWS; i++) {
        printf("%2d", i + 1);
        for (j = 0; j < COLS; j++) {
            switch (board->data[i][j]) {
                case EMPTY:
                    printf(". ");
                    break;
                case BLACK:
                    printf("X ");
                    break;
                case WHITE:
                    printf("O ");
                    break;
                default:
                    break;
            }
        }
        printf("\n");
    }
}

enum Chess check_winner(struct ChessBoard* board) {
    int i, j, k, count;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            if (board->data[i][j] == EMPTY) {
                continue;
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (j + k + 1 < COLS && board->data[i][j + k + 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count == WIN_NUM) {
                return board->data[i][j];
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && board->data[i + k + 1][j] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count == WIN_NUM) {
                return board->data[i][j];
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && j + k + 1 < COLS && board->data[i + k + 1][j + k + 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count == WIN_NUM) {
                return board->data[i][j];
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && j - k - 1 >= 0 && board->data[i + k + 1][j - k - 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count == WIN_NUM) {
                return board->data[i][j];
            }
        }
    }
    return EMPTY;
}

int evaluate(struct ChessBoard* board, int player) {
    int i, j, k, count, value = 0;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            if (board->data[i][j] == EMPTY) {
                continue;
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (j + k + 1 < COLS && board->data[i][j + k + 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count >= WIN_NUM) {
                value += (board->data[i][j] == player) ? 10000 : -10000;
            } else {
                value += (board->data[i][j] == player) ? count * count : -count * count;
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && board->data[i + k + 1][j] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count >= WIN_NUM) {
                value += (board->data[i][j] == player) ? 10000 : -10000;
            } else {
                value += (board->data[i][j] == player) ? count * count : -count * count;
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && j + k + 1 < COLS && board->data[i + k + 1][j + k + 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count >= WIN_NUM) {
                value += (board->data[i][j] == player) ? 10000 : -10000;
            } else {
                value += (board->data[i][j] == player) ? count * count : -count * count;
            }
            for (k = 0, count = 1; k < WIN_NUM - 1; k++) {
                if (i + k + 1 < ROWS && j - k - 1 >= 0 && board->data[i + k + 1][j - k - 1] == board->data[i][j]) {
                    count++;
                } else {
                    break;
                }
            }
            if (count >= WIN_NUM) {
                value += (board->data[i][j] == player) ? 10000 : -10000;
            } else {
                value += (board->data[i][j] == player) ? count * count : -count * count;
            }
        }
    }
    return value;
}

int min_max(struct ChessBoard* board, int depth, int player, int* row, int* col) {
    int i, j, k, value, max_value = -100000, min_value = 100000;
    if (depth == 0) {
        return evaluate(board, player);
    }
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            if (board->data[i][j] != EMPTY) {
                continue;
            }
            board->data[i][j] = player;
            value = min_max(board, depth - 1, (player == BLACK) ? WHITE : BLACK, row, col);
            board->data[i][j] = EMPTY;
            if (player == BLACK) {
                if (value > max_value) {
                    max_value = value;
                    if (depth == WIN_NUM) {
                        *row = i;
                        *col = j;
                    }
                }
            } else {
                if (value < min_value) {
                    min_value = value;
                }
            }
        }
    }
    return (player == BLACK) ? max_value : min_value;
}

void ai_move(struct ChessBoard* board) {
    int row, col;
    min_max(board, WIN_NUM, BLACK, &row, &col);
    board->data[row][col] = BLACK;
    printf("AI move: (%d, %d)\n", row + 1, col + 1);
}

void player_move(struct ChessBoard* board) {
    int row, col;
    printf("Your move (row col): ");
    scanf("%d%d", &row, &col);
    while (row < 1 || row > ROWS || col < 1 || col > COLS || board->data[row - 1][col - 1] != EMPTY) {
        printf("Invalid move, please try again (row col): ");
        scanf("%d%d", &row, &col);
    }
    board->data[row - 1][col - 1] = WHITE;
}

int main() {
    struct ChessBoard board;
    enum Chess winner = EMPTY;
    init_board(&board);
    while (1) {
        print_board(&board);
        player_move(&board);
        winner = check_winner(&board);
        if (winner != EMPTY) {
            break;
        }
        ai_move(&board);
        winner = check_winner(&board);
        if (winner != EMPTY) {
            break;
        }
    }
    print_board(&board);
    if (winner == BLACK) {
        printf("AI wins!\n");
    } else if (winner == WHITE) {
        printf("You win!\n");
    } else {
        printf("Draw!\n");
    }
    return 0;
}

这个程序实现了一个简单的六子棋对弈自走程序，它使用了 min-max 算法和 alpha-beta 剪枝来计算最优的落子位置，同时也实现了基本的人机对弈流程。