以下是一个简单的六子棋人工智能程序实现，采用了极大值极小值算法和α-β剪枝优化。
```
import numpy as np
# 定义棋盘大小
BOARD_SIZE = 15
# 定义棋子类型
WHITE = 1
BLACK = -1
# 定义评估函数
def evaluate(board):
# 统计每个玩家的棋子数
white_count = np.sum(board == WHITE)
black_count = np.sum(board == BLACK)
# 计算得分差
score = white_count - black_count
return score
# 定义极大值极小值算法
def minimax(board, depth, alpha, beta, is_maximizing):
# 判断是否到达搜索深度或者已经有一方胜利
if depth == 0 or check_win(board):
return evaluate(board), None
# 初始化最佳下棋位置
best_move = None
if is_maximizing:
# 最大化玩家下棋
value = float('-inf')
for move in get_moves(board, WHITE):
# 递归调用极大值极小值算法
new_board = make_move(board, WHITE, move)
new_value, _ = minimax(new_board, depth - 1, alpha, beta, False)
if new_value > value:
value = new_value
best_move = move
alpha = max(alpha, value)
if alpha >= beta:
break
else:
# 最小化玩家下棋
value = float('inf')
for move in get_moves(board, BLACK):
# 递归调用极大值极小值算法
new_board = make_move(board, BLACK, move)
new_value, _ = minimax(new_board, depth - 1, alpha, beta, True)
if new_value < value:
value = new_value
best_move = move
beta = min(beta, value)
if alpha >= beta:
break
return value, best_move
# 定义α-β剪枝优化
def minimax_ab(board, depth, alpha, beta, is_maximizing):
# 判断是否到达搜索深度或者已经有一方胜利
if depth == 0 or check_win(board):
return evaluate(board), None
# 初始化最佳下棋位置
best_move = None
if is_maximizing:
# 最大化玩家下棋
value = float('-inf')
for move in get_moves(board, WHITE):
# 递归调用极大值极小值算法
new_board = make_move(board, WHITE, move)
new_value, _ = minimax_ab(new_board, depth - 1, alpha, beta, False)
if new_value > value:
value = new_value
best_move = move
alpha = max(alpha, value)
if alpha >= beta:
break
else:
# 最小化玩家下棋
value = float('inf')
for move in get_moves(board, BLACK):
# 递归调用极大值极小值算法
new_board = make_move(board, BLACK, move)
new_value, _ = minimax_ab(new_board, depth - 1, alpha, beta, True)
if new_value < value:
value = new_value
best_move = move
beta = min(beta, value)
if alpha >= beta:
break
return value, best_move
# 定义获取可落子位置函数
def get_moves(board, player):
moves = []
for i in range(BOARD_SIZE):
for j in range(BOARD_SIZE):
if board[i][j] == 0:
moves.append((i, j))
return moves
# 定义落子函数
def make_move(board, player, move):
new_board = np.copy(board)
new_board[move[0]][move[1]] = player
return new_board
# 定义判断是否有一方胜利函数
def check_win(board):
# 检查行和列
for i in range(BOARD_SIZE):
for j in range(BOARD_SIZE - 5):
row = board[i][j:j+6]
col = board[j:j+6,i]
if np.sum(row) == 6 or np.sum(col) == 6:
return True
if np.sum(row) == -6 or np.sum(col) == -6:
return True
# 检查对角线
for i in range(BOARD_SIZE - 5):
for j in range(BOARD_SIZE - 5):
diagonal1 = [board[i+k][j+k] for k in range(6)]
diagonal2 = [board[i+k][j+5-k] for k in range(6)]
if np.sum(diagonal1) == 6 or np.sum(diagonal2) == 6:
return True
if np.sum(diagonal1) == -6 or np.sum(diagonal2) == -6:
return True
return False
# 测试程序
def test():
# 初始化棋盘
board = np.zeros((BOARD_SIZE, BOARD_SIZE), dtype=int)
# 人工智能为白方
ai_player = WHITE
# 游戏循环
while True:
# 人工智能下棋
_, move = minimax_ab(board, 3, float('-inf'), float('inf'), True)
board = make_move(board, ai_player, move)
print("AI move:", move)
print(board)
# 判断是否游戏结束
if check_win(board):
print("AI wins!")
break
# 玩家下棋
row = int(input("Enter row: "))
col = int(input("Enter column: "))
board[row][col] = BLACK
print(board)
# 判断是否游戏结束
if check_win(board):
print("Player wins!")
break
if __name__ == "__main__":
test()
```
在测试程序中，人工智能采用了α-β剪枝算法搜索深度为3，可以根据需要进行调整。玩家通过输入行和列来落子，程序会在控制台打印出当前棋盘状态并判断游戏是否结束。
1948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
