C语言实现建立博弈树并用α-β剪枝的六子棋代码

以下是C语言实现建立博弈树并用α-β剪枝的六子棋代码：

#include <stdio.h>
#define DEPTH 4
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

int board[6][6]; // 棋盘
int alpha_beta(int depth, int alpha, int beta, int player); // α-β剪枝函数
int evaluate(); // 估值函数
void print_board(); // 打印棋盘

int main() {
    int i, j, x, y;
    int player = 1; // 玩家
    int result = 0; // 结果
    printf("六子棋游戏开始！\n");
    for(i = 0; i < 6; i++) {
        for(j = 0; j < 6; j++) {
            board[i][j] = 0; // 初始化棋盘
        }
    }
    print_board();
    while(1) {
        if(player == 1) {
            printf("请玩家1输入下棋位置(x, y)：");
            scanf("%d%d", &x, &y);
            if(board[x][y] == 0) {
                board[x][y] = 1;
                player = 2; // 转到玩家2
            } else {
                printf("该位置已被占用，请重新输入！\n");
            }
        } else {
            printf("玩家2正在思考……\n");
            result = alpha_beta(0, -1000000, 1000000, 2);
            printf("玩家2选择了(%d, %d)处下棋，估值为%d\n", x, y, result);
            board[x][y] = 2;
            player = 1; // 转到玩家1
        }
        print_board();
        if(evaluate() == 1) {
            printf("玩家1获胜！\n");
            break;
        } else if(evaluate() == 2) {
            printf("玩家2获胜！\n");
            break;
        } else if(evaluate() == 3) {
            printf("平局！\n");
            break;
        }
    }
    return 0;
}

int alpha_beta(int depth, int alpha, int beta, int player) {
    int i, j, k;
    int value;
    int max_value = -1000000;
    int min_value = 1000000;
    if(depth == DEPTH) {
        return evaluate();
    }
    for(i = 0; i < 6; i++) {
        for(j = 0; j < 6; j++) {
            if(board[i][j] == 0) {
                if(player == 2) {
                    board[i][j] = 2;
                    value = alpha_beta(depth + 1, alpha, beta, 1);
                    max_value = MAX(max_value, value);
                    alpha = MAX(alpha, value);
                    if(beta <= alpha) {
                        board[i][j] = 0;
                        break;
                    }
                } else {
                    board[i][j] = 1;
                    value = alpha_beta(depth + 1, alpha, beta, 2);
                    min_value = MIN(min_value, value);
                    beta = MIN(beta, value);
                    if(beta <= alpha) {
                        board[i][j] = 0;
                        break;
                    }
                }
                board[i][j] = 0;
            }
        }
    }
    if(player == 2) {
        return max_value;
    } else {
        return min_value;
    }
}

int evaluate() {
    int i, j, k;
    int count1, count2;
    // 判断行
    for(i = 0; i < 6; i++) {
        for(j = 0; j < 2; j++) {
            count1 = 0;
            count2 = 0;
            for(k = 0; k < 6; k++) {
                if(board[i][j + k] == 1) {
                    count1++;
                    count2 = 0;
                } else if(board[i][j + k] == 2) {
                    count2++;
                    count1 = 0;
                } else {
                    count1 = 0;
                    count2 = 0;
                }
                if(count1 == 4) {
                    return 1;
                }
                if(count2 == 4) {
                    return 2;
                }
            }
        }
    }
    // 判断列
    for(i = 0; i < 6; i++) {
        for(j = 0; j < 2; j++) {
            count1 = 0;
            count2 = 0;
            for(k = 0; k < 6; k++) {
                if(board[j + k][i] == 1) {
                    count1++;
                    count2 = 0;
                } else if(board[j + k][i] == 2) {
                    count2++;
                    count1 = 0;
                } else {
                    count1 = 0;
                    count2 = 0;
                }
                if(count1 == 4) {
                    return 1;
                }
                if(count2 == 4) {
                    return 2;
                }
            }
        }
    }
    // 判断正对角线
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 2; j++) {
            count1 = 0;
            count2 = 0;
            for(k = 0; k < 6; k++) {
                if(board[i + k][j + k] == 1) {
                    count1++;
                    count2 = 0;
                } else if(board[i + k][j + k] == 2) {
                    count2++;
                    count1 = 0;
                } else {
                    count1 = 0;
                    count2 = 0;
                }
                if(count1 == 4) {
                    return 1;
                }
                if(count2 == 4) {
                    return 2;
                }
            }
        }
    }
    // 判断反对角线
    for(i = 0; i < 2; i++) {
        for(j = 4; j < 6; j++) {
            count1 = 0;
            count2 = 0;
            for(k = 0; k < 6; k++) {
                if(board[i + k][j - k] == 1) {
                    count1++;
                    count2 = 0;
                } else if(board[i + k][j - k] == 2) {
                    count2++;
                    count1 = 0;
                } else {
                    count1 = 0;
                    count2 = 0;
                }
                if(count1 == 4) {
                    return 1;
                }
                if(count2 == 4) {
                    return 2;
                }
            }
        }
    }
    // 判断平局
    for(i = 0; i < 6; i++) {
        for(j = 0; j < 6; j++) {
            if(board[i][j] == 0) {
                return 0; // 棋盘还有空位，未结束
            }
        }
    }
    return 3; // 棋盘已满，平局
}

void print_board() {
    int i, j;
    printf("  0 1 2 3 4 5\n");
    for(i = 0; i < 6; i++) {
        printf("%d ", i);
        for(j = 0; j < 6; j++) {
            if(board[i][j] == 0) {
                printf("+ ");
            } else if(board[i][j] == 1) {
                printf("O ");
            } else {
                printf("X ");
            }
        }
        printf("\n");
    }
}

在该代码中，我们使用了一个二维数组`board`来表示棋盘，其中0表示空位，1表示玩家1的棋子，2表示玩家2的棋子。`alpha_beta`函数是α-β剪枝函数，其中`depth`表示当前深度，`alpha`和`beta`表示当前的α和β值，`player`表示当前轮到的玩家。`evaluate`函数是估值函数，用于判断游戏是否结束以及胜负情况。`print_board`函数用于打印当前棋盘状态。

在主函数中，我们先初始化棋盘，然后开始游戏循环，每次循环中根据当前玩家输入下棋位置或者调用`alpha_beta`函数选择下棋位置，然后判断游戏是否结束以及胜负情况，最后打印当前棋盘状态。

在这个六子棋游戏中，我们使用了α-β剪枝算法来优化博弈树的搜索，从而提高了程序的效率，使得程序可以更快地做出决策。