python藉助遞歸思想判斷當前黑棋着子時，黑棋是否勝出

python3實現遞歸與c是一樣的，無非就是某個函數自己調用自己而已。我寫了個可以隨時判斷黑白棋手五子棋博弈時，黑棋的某次着子是否會導致黑棋獲勝。第一步：採用遞歸的方式直接找到與當前着子位置有最鄰近並且已經被着黑子的位置，然後基於這些位置，再遞歸的尋找。最後尋找到所有的“鏈路”。第二步：我們可基於當前黑棋的着子位置，找到可以使得黑棋獲勝的所有情況，就8種。第三步：很簡單，直接判斷就可以了。

        代碼如下：

def get_closed_positions(board_status, cur_pos, size):
    """
    得到當前棋子最鄰近的位置，並且得到這些位置的着子情況
    :param board_status:  當前棋盤狀態
    :param cur_pos:  當前位置座標
    :param size:  棋盤大小
    :return:
    """
    def select(pos):
        if board_status.get(pos) == 1:  # 黑棋
            pos_list.append(pos)
    pos_list = []
    pos_x, pos_y = cur_pos
    # 正上方
    if pos_y - 1 >= 0:
        select((pos_x, pos_y - 1))
    # 正下方
    if pos_y + 1 < size:
        select((pos_x, pos_y + 1))
    # 左邊
    if pos_x - 1 >= 0:
        select((pos_x - 1, pos_y))
    # 右邊
    if pos_x + 1 < size:
        select((pos_x + 1, pos_y))
    print('return pos_list:', pos_list)
    return pos_list


def check_win(size, board_status, start_point):
    """

    :param size:
    :param board_status:
    :param start_point:
    :return:
    """
    pos_list = get_closed_positions(board_status, start_point, size)
    if len(black_point) == 0:
        black_point.extend(pos_list)
    else:
        pos_list = list(set(pos_list).difference(set(black_point)))  # list求差集
        black_point.extend(pos_list)
    print('black_point:', black_point)
    if len(pos_list) > 0:
        print('pos_list:', pos_list)
        for cur_parent_point in pos_list:  # 得到已經着過子的父節點
            check_win(size, board_status, cur_parent_point)
    return


def create_dtynamic_points(size, start):
    all_path = []
    if start[1] - 4 >= 0:
        all_path.append([(start[0], start[1] - index) for index in range(1, 5, 1)])

    if start[1] + 4 < size:
         all_path.append([(start[0], start[1] + index) for index in range(1, 5, 1)])

    if start[0] + 4 < size:
         all_path.append([(start[0] + index, start[1]) for index in range(1, 5, 1)])
    if start[0] - 4 >= 0:
         all_path.append([(start[0] - index, start[1]) for index in range(1, 5, 1)])

    if (start[1] - 4 >= 0) and (start[0] + 4 < size):
         all_path.append([(start[0] + index, start[1] - index) for index in range(1, 5, 1)])

    if (start[1] - 4 >= 0) and (start[0] - 4 >= 0):
         all_path.append([(start[0] - index, start[1] - index) for index in range(1, 5, 1)])

    if (start[1] + 4 < size) and (start[0] - 4 >= 0):
         all_path.append([(start[0] - index, start[1] + index) for index in range(1, 5, 1)])

    if (start[1] + 4 < size) and (start[0] + 4 < size):
         all_path.append([(start[0] + index, start[1] + index) for index in range(1, 5, 1)])
    return all_path

if __name__ == '__main__':
    global black_point
    black_point = []
    board = dict()
    size = 15
    for row in range(size):
        for col in range(size):
            board.update({(row, col): 0})

    board.update({(2, 3): 1})
    board.update({(2, 2): 1})
    board.update({(2, 1): 1})
    board.update({(3, 2): 1})
    board.update({(2, 0): 1})
    board.update({(4, 1): 1})
    board.update({(5, 0): 1})

    board.update({(3, 3): 1})
    board.update({(4, 2): 1})
    board.update({(5, 1): 1})
    board.update({(6, 0): 1})
    check_win(6, board, (2, 4))
    # 然後判斷是否贏。
    dynamic_point = create_dtynamic_points(6, (2, 4))
    print('dynamic_point:', dynamic_point)
    log = '黑棋選手輸'
    for cur_points in dynamic_point:
        if cur_points[0] in black_point:
            log = '黑棋選手贏......'
            break
    print('log:', log)

結果：

dynamic_point: [[(2, 3), (2, 2), (2, 1), (2, 0)]]
log: 黑棋選手贏......

當然，程序像這樣寫，效率不高，可以寫的很簡潔，不過我這也是寫給別人看的，要求低，儘量簡單。