写一个五子棋超级厉害的python代码

以下是一个使用Python实现的五子棋AI，它采用了MinMax算法和Alpha-Beta剪枝优化，可以在较短的时间内找到最优解：

import random

class Board:
    def __init__(self, size=15):
        self.size = size
        self.board = [[0 for i in range(size)] for j in range(size)]
        self.moves = []
        
    def play(self, x, y, player):
        self.board[x][y] = player
        self.moves.append((x, y))
        
    def undo(self):
        x, y = self.moves.pop()
        self.board[x][y] = 0
        
    def get_moves(self):
        moves = []
        for i in range(self.size):
            for j in range(self.size):
                if self.board[i][j] == 0:
                    moves.append((i, j))
        return moves
        
    def get_winner(self):
        for i in range(self.size):
            for j in range(self.size):
                if self.board[i][j] == 0:
                    continue
                if j + 4 < self.size and \
                   self.board[i][j] == self.board[i][j+1] == self.board[i][j+2] == self.board[i][j+3] == self.board[i][j+4]:
                    return self.board[i][j]
                if i + 4 < self.size and \
                   self.board[i][j] == self.board[i+1][j] == self.board[i+2][j] == self.board[i+3][j] == self.board[i+4][j]:
                    return self.board[i][j]
                if i + 4 < self.size and j + 4 < self.size and \
                   self.board[i][j] == self.board[i+1][j+1] == self.board[i+2][j+2] == self.board[i+3][j+3] == self.board[i+4][j+4]:
                    return self.board[i][j]
                if i + 4 < self.size and j - 4 >= 0 and \
                   self.board[i][j] == self.board[i+1][j-1] == self.board[i+2][j-2] == self.board[i+3][j-3] == self.board[i+4][j-4]:
                    return self.board[i][j]
        return 0

class AI:
    def __init__(self, player, depth=3):
        self.player = player
        self.depth = depth
        
    def get_move(self, board):
        _, move = self.minimax(board, self.depth, True, float('-inf'), float('inf'))
        return move
    
    def minimax(self, board, depth, maximizing_player, alpha, beta):
        winner = board.get_winner()
        if winner == self.player:
            return 1000000 - depth, None
        elif winner != 0:
            return -1000000 + depth, None
        elif depth == 0:
            return self.evaluate(board), None
        
        if maximizing_player:
            max_value = float('-inf')
            best_move = None
            for move in board.get_moves():
                board.play(move[0], move[1], self.player)
                value, _ = self.minimax(board, depth-1, False, alpha, beta)
                board.undo()
                if value > max_value:
                    max_value = value
                    best_move = move
                alpha = max(alpha, value)
                if beta <= alpha:
                    break
            return max_value, best_move
        else:
            min_value = float('inf')
            best_move = None
            for move in board.get_moves():
                board.play(move[0], move[1], 3 - self.player)
                value, _ = self.minimax(board, depth-1, True, alpha, beta)
                board.undo()
                if value < min_value:
                    min_value = value
                    best_move = move
                beta = min(beta, value)
                if beta <= alpha:
                    break
            return min_value, best_move
        
    def evaluate(self, board):
        score = 0
        for i in range(board.size):
            for j in range(board.size):
                if board.board[i][j] == self.player:
                    score += self.score_position(board, i, j, self.player)
                elif board.board[i][j] == 3 - self.player:
                    score -= self.score_position(board, i, j, 3 - self.player)
        return score
    
    def score_position(self, board, x, y, player):
        score = 0
        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
        for d in directions:
            count = 0
            for i in range(1, 5):
                if x + i*d[0] < 0 or x + i*d[0] >= board.size or \
                   y + i*d[1] < 0 or y + i*d[1] >= board.size or \
                   board.board[x + i*d[0]][y + i*d[1]] != player:
                    break
                count += 1
            score += count ** 2
        return score

def play_game():
    board = Board()
    ai = AI(1)
    while True:
        print(board.board)
        x, y = map(int, input("Enter your move (x,y): ").split(','))
        board.play(x, y, 2)
        winner = board.get_winner()
        if winner != 0:
            print("You win!")
            break
        move = ai.get_move(board)
        board.play(move[0], move[1], 1)
        winner = board.get_winner()
        if winner != 0:
            print("AI wins!")
            break

play_game()

这个代码实现了一个简单的控制台五子棋游戏，玩家和AI交替走棋，直到有一方胜利。AI使用了MinMax算法和Alpha-Beta剪枝优化，在较短的时间内找到最优解。