Question

我正在用迭代解决N皇后问题（没有递归）。我现在面临的问题是重复的解决方案。例如4 x 4板有2个解决方案我正在打印4个解决方案，所以说我找到了相同的解决方案两次。

让我进入代码以获得更好的概述：

def solution(self):
        queen_on_board = 0
        for row in range(self.N):
            for col in range(self.N):
                self.board[row][col] = 'Q'
                queen_on_board = queen_on_board + 1
                print ("(row,col) : ", row, col)
                squares_list = self.get_posible_safe_squares(row,col)
                for square in squares_list:
                    for x,y in square.items():
                        if self.isTheQueenSafe(x,y):
                            self.board[x][y] = 'Q'
                            queen_on_board = queen_on_board + 1
                print ("Queen on board", queen_on_board)
                if queen_on_board == 4:
                    self.print_the_board()
                self.reset_the_board()
                queen_on_board = 0

所以你可以看到我正在遍历每一行和一些列。这个特定的实现使我4解决方案2相同。

(row,col) :  0 1
Queen on board 4
['.', 'Q', '.', '.'] 

['.', '.', '.', 'Q'] 

['Q', '.', '.', '.'] 

['.', '.', 'Q', '.'] 

(row,col) :  0 2
Queen on board 4
['.', '.', 'Q', '.'] 

['Q', '.', '.', '.'] 

['.', '.', '.', 'Q'] 

['.', 'Q', '.', '.']

(row,col) :  1 0
Queen on board 4
['.', '.', 'Q', '.'] 

['Q', '.', '.', '.'] 

['.', '.', '.', 'Q'] 

['.', 'Q', '.', '.'] 

(row,col) :  2 0
Queen on board 4
['.', 'Q', '.', '.'] 

['.', '.', '.', 'Q'] 

['Q', '.', '.', '.'] 

['.', '.', 'Q', '.']

我想避免重复。如果有人能指出我正确的方向，那就太棒了。

get_posible_safe_squares（）方法在棋盘中查找可能安全的女王方块。

def get_posible_safe_squares(self, row, col):
        ret = []
        for i in range(self.N):
            for j in range(self.N):
                if i != row and j !=col:
                    if i + j != row + col and i - j != row - col:
                        d = { i:j }
                        ret.append(d)
        return ret

Answer 1

你得到重复的原因是你也把皇后放在你放置第一个皇后的位置之前。因此，你的第一个女王将在每个广场上获得它的位置，但是其他女王可以在一个广场上占据他们的位置，在早先的迭代中第一个女王已经被放置。这意味着两个皇后被“交换”，但基本上建立了相同的解决方案。

我试图重写你的解决方案，但后来又决定改变以下几个方面：

遗憾的是，放置第一张女王的代码与放置其他女王的代码不同。应该可以为此重用相同的代码。
我不会使用单例字典来表示正方形。元组(i, j)似乎比{ i:j }更自然。
当您需要的唯一信息是电路板尺寸和 - 当放置女王时 - 存放女王的位置时，存储整个电路板可能有点过分。由于同一行上不能有两个皇后，您可以将其作为列索引列表。因此queens[2] == 3表示第2行和第3列有一个女王。一旦有了此列表，您也不需要queens_on_board，因为len(queens)将返回该值。 print_the_board可以根据该信息轻松生成点和“Q”。
由于您具有isTheQueenSafe功能，因此您并不需要get_posible_safe_squares。在放置第一个女王之后，你已经把它称之为非常武断，但是在放置任何其他女王之后就没有。
你混合了两个命名约定：camelCase和强调，所以我会选择后者并使用is_queen_safe。

在repl.it

上查看它

以下是代码：

class Board:
    def __init__(self, size):
        self.N = size
        self.queens = [] # list of columns, where the index represents the row

    def is_queen_safe(self, row, col):
        for r, c in enumerate(self.queens):
            if r == row or c == col or abs(row - r) == abs(col - c):
                return False
        return True

    def print_the_board(self):
        print ("solution:")
        for row in range(self.N):
            line = ['.'] * self.N
            if row < len(self.queens):
                line[self.queens[row]] = 'Q'
            print(''.join(line))

    def solution(self):
        self.queens = []
        col = row = 0
        while True:
            while col < self.N and not self.is_queen_safe(row, col):
                col += 1
            if col < self.N:
                self.queens.append(col)
                if row + 1 >= self.N:
                    self.print_the_board()
                    self.queens.pop()
                    col = self.N
                else:
                    row += 1
                    col = 0
            if col >= self.N:
                # not possible to place a queen in this row anymore
                if row == 0:
                    return # all combinations were tried
                col = self.queens.pop() + 1
                row -= 1

q = Board(5)
q.solution()

Answer 2

您的算法错过了几个案例，纠正重复项的方法非常复杂。相反，我建议你模仿递归。

从一个简单的递归函数开始：

def is_safe(board, x, y, c):
    for p in [board[i] for i in range(0, c)]:
        if p[0] == x or p[1] == y or x + y == p[0] + p[1] or x - y == p[0] - p[1]:
            return False

    return True


def nqueen_rec(board, n, c):
    if c == n:
        print(board)
    else:
        for x in range(0, n):
            if is_safe(board, x, c, c):
                board[c] = (x, c)
                nqueen_rec(board, n, c + 1)

在深入到递归时更改的唯一参数是c，因此我们可以轻松地将行为更改为递归的行为：

def nqueen_nrec(n):
    c = 0
    step = [0 for x in range(0, n + 1)]
    board = [(x, x) for x in range(0, n)]

    while c != -1:
        if c == n:
            print(board)
            c -= 1
            step[c] += 1
        elif step[c] == n:
            c -= 1
            step[c] += 1
        elif is_safe(board, step[c], c, c):
            board[c] = (step[c], c)
            c += 1
            step[c] = 0
        else:
            step[c] += 1

该算法跟踪当前的部分解决方案和下一个可能的解决方案，并通过开始while - 循环的新运行而不是递归函数调用来模拟递归深度。

避免在N Queen迭代解决方案中重复（不允许递归）

2 个答案: