八皇后问题

八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。

 

这个问题我思考了好几天，然后自己用python实现的，详细思路代码中体会，这个应该是最简单的实现方式了

实现方式：遍历枚举

直接上代码:

#  这一段是搞出来一个坐标系
# lisx = []
# for i in range(8):
#     x = [i for j in range(8)]
#     lisx.append(x)
# lisy = list(range(8))
#
# lis = [(list(zip(lisx[i], lisy))) for i in range(8)]


#  3种方法，反转列表
# lis.reverse()   # reverse方法没有返回值，它修改的是lis列表本身
# print(lis)
# print(reversed(lis))    # reversed返回的是一个对象，<list_reverseiterator object at 0x00000000024E9B00>
# print(list(reversed(lis)))
# print(lis[::-1])
# print(lis.sort(reverse=True))  # lis.sort()方法也是没有返回值的;
# 也可以指定参数key用哪个关键参数，可以指定key等于一个函数
# print(lis)
import random

lis = [[0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0]]


#  这里的(x,y)对应lis的行和列

#  为了方便8*8的国际棋盘对应成搞成坐标系的样子，更好的处理对角线的排查，K斜率（对角线）
# [[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7)],
#  [(1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7)],
#  [(2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7)],
#  [(3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7)],
#  [(4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7)],
#  [(5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7)],
#  [(6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7)],
#  [(7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)]]


def check_position(y, x):
    """
    初始状态每个格子都是0
    判断的标志是，如果已经放了皇后lis[i][j] ,这里就是1 ，代表已经被占了

    """
    global lis
    for i in range(8):
        # 横向检查
        if lis[y][i] == 1:
            return False
    print(lis[y])
    print('横向检查完毕')
    for j in range(8):
        # 纵向检查
        if lis[j][x] == 1:
            return False

        print(lis[j][x])
    print('纵向检查完毕')

    #  对角线的检测思路是，把对角线上的 横坐标 = 0 ~ 7 上的点全部判断一遍
    #  接下来 i 就是横坐标， j 就是纵坐标
    for i in range(8):
        # 一次函数 y = kx + b
        # 45°角对角线，斜率k=1
        b = y - x
        j = i + b  # 带入方程得纵坐标
        if 0 <= i < 8 and 0 <= j < 8:

            print((i, j))
            if lis[j][i] == 1:
                return False

    print('45°角检查完毕')

    for i in range(8):
        # 一次函数 y = kx + b
        # 135°角对角线，斜率k=-1
        b = y + x
        j = -i + b  # 带入方程得纵坐标
        if 0 <= i < 8 and 0 <= j < 8:

            print((i, j))
            if lis[j][i] == 1:
                return False
    print('135°角检查完毕')
    return True


def scan(y):
    """  扫描整层 ，也就是一行
        右移旧皇后产生新皇后返回True
        没有旧皇后，扫描该行产生新皇后，返回 True
        否则，产生不了新皇后 ，返回False
    """
    result = False

    if 1 in lis[y]:  # 去找该行的旧皇后
        x = lis[y].index(1)  # 获取旧皇后的横坐标
        lis[y][x] = 0  # 废掉旧皇后
        while x < 7:  # 这里不是8，而是7，因为x = x+1 = 6+1 旧皇后已经在最右侧，说明无法右移了
            x = x + 1
            if check_position(y, x):
                lis[y][x] = 1  # 获取新皇后
                result = True
                break
    else:  # 该行没有旧皇后就去找新皇后
        x = 0
        while x < 8:
            x = x + 1
            if check_position(y, x):
                lis[y][x] = 1  # 获取新皇后
                result = True
                break
    return result




def go_back(y):
    """递归回溯，
    返回
    如果前一层，有旧皇后，废掉旧皇后，右移得到新皇后的 y+1 ;也就是纵坐标
    如果前一层，没有旧皇后，就扫描得到该行的新皇后的 y+1 ;
    如果前一层得不到新皇后，就继续向前一层的前一层回溯,及 y-1

    直到回溯到第0层，必然能够取到新皇后，就返回新皇后的 y +1

    综上就是返回  前一层新皇后的 y + 1

    """
    global lis

    if y > 0:
        if scan(y):
            return y + 1
    else:
        if scan(y):
            return y + 1

    return go_back(y - 1)


def get_count():
    """  计算count """
    count = 0
    for i in range(8):
        if 1 in lis[i]:
            count += 1
    return count




def get_queen(lis):
    """  获得我们的皇后 """
    x = random.randint(0, 7)        #random.randint(a,b)  包括a,b
    y = 0
    while 0 <= y < 8 and 0 <= x < 8:

        print('x = {}'.format(x))
        print('y = {}'.format(y))
        if check_position(y, x):
            lis[y][x] = 1
            print('第{}个皇后,在{}层，{}列'.format(get_count(), y, x))
            y += 1
            x = 0
        else:
            x += 1
            if x == 8:
                y = go_back(y-1)
                x = 0
                print('回溯到上一层{}'.format(y))  # 我们回溯到第1层，其实就已经扫描了第0层

            #  下面是一个判断跳出循环的条件；用了一个count变量来计数
            #  如果已经放满八个皇后了，就退出
        count = get_count()
        if count == 8:
            break
    print('-' * 50, get_count())
    return lis


queen_lis = get_queen(lis)
print(queen_lis)

# [[0, 0, 0, 0, 0, 1, 0, 0],
#  [1, 0, 0, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 1, 0, 0, 0],
#  [0, 1, 0, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 0, 0, 0, 1],
#  [0, 0, 1, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 0, 0, 1, 0],
#  [0, 0, 0, 1, 0, 0, 0, 0]]

#  细节
"""
Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points
"""

 

 

我写完了，想不能优化一下代码，

我的get_queen（）函数里面的while 判断break条件是，写了一个get_count()函数，判断跳出循环；
大家，给我指点一下，有没有更好的判断跳出，条件

还有个小的问题，想问一下大伙，我怎么去判断总共有多少种摆放方法呢？
他们是在怎么知道总共92种的？
我想过，用一个集合把每次的lis结果,add到集合里，但是我需要循环多少次呢？
换句话说哦就是，8*8的棋盘放8个皇后，理想状态下，最多有多少种方法，不考虑皇后相互吃掉的限制。

ps:（饿了，吃饭去了┯┯┯）


今天再看廖雪峰大神的python教程,领悟，更加简洁的方式快速生成，（8*8的国际象棋的坐标系）

>>> [(x,y) for x in range(8) for y in range(8)]
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7),
 　(1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7),
 　(2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7),
 　(3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7),
 　(4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7),
 　(5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7),
 　(6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7),
 　(7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)]

 

生成棋盘初始化，状态

>>> lis = [0 for i in range(8) for j in range(8)]
>>> len(lis)
64
>>> def get_result(L = []):
    res_lis = []
    n = len(lis)
    for i in lis:
        L.append(i)
        n = n - 1
        if n%8 == 0 and n != len(lis):
            res_lis.append(L)
            L = []
    return res_lis

>>> res_lis = get_result()
>>> res_lis
[[0, 0, 0, 0, 0, 0, 0, 0], 
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0], 
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0]]
>>> len(res_lis)
8