leetcode#51 N皇后

题目要求：
在一个N*N大小的棋盘上，放置N个皇后棋子，保证每个棋子不互相攻击（皇后的攻击范围为所在行列和主次对角线）
列出所有解法

优化思路：
原先的回溯关系，过于繁琐，许多不必要的情况也被回溯了。如第一行中放置了一个Q 之后的回溯是在当前位置之后的所有位置进行回溯。实际上，只要第一行中放置了皇后，之后的皇后只能放在第一行之后的所有行中。这样至多减少n中情况的回溯。能够大大减少耗时。

class Solution(object):
    def __init__(self):
        self.count = 0
        self.res = []
        self.hill = []
        self.dale = []
        self.chess_map = []

    def solveNQueens(self,n:int):
        self.chess_map = [['.'] * n for _ in range(n)]
        def check(row,col):
            if row+col in self.hill or row-col in self.dale:
                return False
            for i in range(n):
                if self.chess_map[i][col] =='Q':
                    return False
            return True

        def backtrack(row=0):
            temp = []
            for col in range(n):
                if check(row,col) :
                    self.chess_map[row][col] = 'Q'
                    self.hill.append(row+col)
                    self.dale.append(row-col)
                    if row+1 == n :
                        for m in range(len(self.chess_map)):
                            temp.append("".join(self.chess_map[m]))
                        self.res.append(temp)
                    else:
                        backtrack(row+1)
                    self.chess_map[row][col] = '.'
                    self.hill.pop()
                    self.dale.pop()
        backtrack()
        return self.res




print(Solution().solveNQueens(9))

==原思路=

思路：
一道十分典型也算较为复杂的回溯法算法
实际是对枚举的优化
首先先在棋盘最左上角放置一个皇后，然后向后寻找下一个可以放置皇后的位置，找到后放下下一个皇后，再向后寻找下一个可以放下皇后的位置。直到放置完所有可以放置的位置。如果棋盘上的总棋子数等于N，则返回一个正确解，并将最后一个皇后移除，继续向后寻找下一个皇后位置。直到整个棋盘被历遍。
如果总棋子数小于N 则回溯到上一个皇后的位置并移除，向后寻找满足后续条件的放置位置。

算法实现：
对于回溯问题，还是两个最关键的条件确定
1.终止条件：第一个棋子已经历遍整个棋盘可以被放置的所有位置。（注意本题要求是输出所有解，不能找到一个解后就终止循环，而是找到一个解后继续向后寻找）
2.回溯条件：
同样是因为需要列出所有解，所以会存在两个回溯条件。
（1）历遍完整个棋盘后，所有情况的棋子总数均小于N，则需要回溯到上一个皇后放置的位置，向后寻找一个新的位置继续后续循环
（2）找到了一个正确解。此时需要将最后一个皇后移除，并向后寻找看有没有新的解。

代码：

import copy


class Solution(object):
    def __init__(self):
        self.count = 0
        self.res = []
        self.save = []

    def solveNQueens(self,n:int):
        chess_map = [['.'] * n for _ in range(n)]
        def check(row, col, chess_map):
            n = len(chess_map)
            for i in range(n):
                if chess_map[row][i] == 'Q':
                    return False
            for i in range(n):
                if chess_map[i][col] == 'Q':
                    return False
            x = row
            y = col
            while (y>-1 and x<n):
                if chess_map[x][y] == 'Q':
                    return False
                else:
                    x+=1
                    y-=1
            x = row
            y = col
            while (x>-1 and y<n):
                if chess_map[x][y] == 'Q':
                    return False
                else:
                    x-=1
                    y+=1
            x = row
            y = col
            while (y<n and x<n):
                if chess_map[x][y] == 'Q':
                    return False
                else:
                    x+=1
                    y+=1
            x = row
            y = col
            while (x>-1 and y>-1):
                if chess_map[x][y] == 'Q':
                    return False
                else:
                    x-=1
                    y-=1
            return True

        def backtrack(n, row, col, chess_map):
            temp = []
            if self.count == n:
                self.save = copy.deepcopy(chess_map)
                for m in range(len(self.save)):
                    temp.append("".join(self.save[m]))
                self.res.append(temp)
                chess_map[row][col] = '.'
                self.count -=1
                return True
            for i in range(n):
                for j in range(n):
                    if i <row or (i==row and j<=col) :
                        continue
                    if check(i, j, chess_map) :
                        chess_map[i][j] = 'Q'
                        self.count += 1
                        if backtrack(n, i, j, chess_map):
                            continue
                        else:
                            chess_map[i][j] = '.'
                            self.count -=1
                            continue
                    else:
                        chess_map[i][j] = '.'
        backtrack(n, -1, -1, chess_map)
        return self.res


print(Solution().solveNQueens(9))

过程踩坑：
1.棋盘的初始化。
一开始没仔细看题，按照自己的想法 用[[’*’] X n for _ in range(n)] （X为乘号 实际为星号 然而憨憨csdn星号是表示斜体。。都没找到在哪取消）构建了行为list的棋盘。实际上题目要求的是字符串。然后以为只需要用str（）函数改写即可。之后遇到的问题为python中字符串为不可变元素。直接用

chess_map[i][j] == 'Q'

赋值时会出错。所以最后解决办法是在最后输出时，用join函数将列表改写为字符串
2.两个回溯条件
一开始没有考虑到两个回溯条件，代码写完发现始终只能输出找到的第一个解。
之后想到了找到解后需要将最后一个皇后还原，然后回到主循环continue 继续检验下一个位置是否符合
3.超时
实际上这个代码在leetcode上输入为9时超时了。初步分析是对于棋子是否放置的位置检验过于复杂。每个棋子对其所在行列和双对角线都进行了一次检测。后续需要优化

总结：
一道典型的回溯加减枝问题。
此后的回溯法问题中，始终都要分析清楚循环的终止条件和回溯条件。
借助Backtrack函数，构造回溯过程。并理清回调关系