博弈树解决井字棋实例代码

下面是一个使用博弈树解决井字棋的 Python 代码示例：

# 定义井字棋棋盘
board = [
    ['_', '_', '_'],
    ['_', '_', '_'],
    ['_', '_', '_']
]

# 定义玩家和电脑的棋子
player = 'X'
computer = 'O'

# 检查是否有玩家或电脑获胜
def check_win(board, player):
    # 检查行
    for row in range(3):
        if board[row][0] == board[row][1] == board[row][2] == player:
            return True
    # 检查列
    for col in range(3):
        if board[0][col] == board[1][col] == board[2][col] == player:
            return True
    # 检查对角线
    if board[0][0] == board[1][1] == board[2][2] == player:
        return True
    if board[0][2] == board[1][1] == board[2][0] == player:
        return True
    return False

# 获取所有可行的下一步棋
def get_moves(board):
    moves = []
    for row in range(3):
        for col in range(3):
            if board[row][col] == '_':
                moves.append((row, col))
    return moves

# 评估当前棋局的得分
def evaluate(board):
    if check_win(board, computer):
        return 1
    elif check_win(board, player):
        return -1
    else:
        return 0

# 构建博弈树
def minimax(board, depth, maximizing_player):
    score = evaluate(board)
    # 如果已经有获胜者或达到最大深度，则返回当前得分
    if score != 0 or depth == 0:
        return score
    # 如果是电脑的回合
    if maximizing_player:
        best_score = float('-inf')
        for move in get_moves(board):
            board[move[0]][move[1]] = computer
            score = minimax(board, depth - 1, False)
            board[move[0]][move[1]] = '_'
            best_score = max(best_score, score)
        return best_score
    # 如果是玩家的回合
    else:
        best_score = float('inf')
        for move in get_moves(board):
            board[move[0]][move[1]] = player
            score = minimax(board, depth - 1, True)
            board[move[0]][move[1]] = '_'
            best_score = min(best_score, score)
        return best_score

# 电脑下棋
def computer_move(board):
    best_score = float('-inf')
    best_move = None
    for move in get_moves(board):
        board[move[0]][move[1]] = computer
        score = minimax(board, 4, False)
        board[move[0]][move[1]] = '_'
        if score > best_score:
            best_score = score
            best_move = move
    board[best_move[0]][best_move[1]] = computer

# 玩家下棋
def player_move(board):
    valid_move = False
    while not valid_move:
        row = int(input("请输入行（1-3）：")) - 1
        col = int(input("请输入列（1-3）：")) - 1
        if row >= 0 and row <= 2 and col >= 0 and col <= 2 and board[row][col] == '_':
            board[row][col] = player
            valid_move = True
        else:
            print("无效的位置，请重试。")

# 打印棋盘
def print_board(board):
    for row in board:
        print(row)

# 主游戏循环
while True:
    print_board(board)
    player_move(board)
    if check_win(board, player):
        print("你赢了！")
        break
    computer_move(board)
    if check_win(board, computer):
        print("电脑赢了。")
        break
    if len(get_moves(board)) == 0:
        print("平局。")
        break

此代码使用了 minimax 算法实现了电脑的决策，并使用了 alpha-beta 剪枝来优化博弈树的搜索效率。在每次电脑回合时，它会搜索四层深度，这可以保证它能够找到一个相对较好的走法。