51. N-Queens

https://leetcode.com/problems/n-queens/description/
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。皇后的走法:可以到达横向、纵向和斜线(45度,135度)的任意距离。
给定一个整数 n,返回所有不同的 n 皇后问题的解决方案。
每一种解法包含一个明确的 n 皇后问题的棋子放置方案,该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

思路:回溯。从第一行开始填,每次对0~n-1列遍历,检查每个位置是否合法,若合法则填入,并递归进入第二行。

用到了python的多变量for循环,用zip函数。注意循环的终点以范围最短的为准:

>>> for i,j,k in zip(range(9), range(1,9), range(2,11)):  #每次对三个变量分别循环
...    print(i,j,k)
... 
0 1 2
1 2 3
2 3 4
3 4 5
4 5 6
5 6 7
6 7 8
7 8 9  #j先到达终点,所有变量一起结束

此外由于回溯棋盘时,string的元素不能修改,因此用一个二维字符列表,而不是一维string列表来表示棋盘。而最终结果要求一个一维string列表,因此得到的结果还需要转换,将字符列表转为string,用join函数:
https://blog.csdn.net/u013810296/article/details/57082163

class Solution:
    def solveNQueens(self, n):
        """
        :type n: int
        :rtype: List[List[str]]
        """
        record = []
        board = [['.'] * n for _ in range(n)]  #注意二维列表的创建方式
        self.solve(record, board, 0, n)
        return record

    def solve(self, record, board, row, n):
        if row == n:  #得到一个结果
            res = []  #记录一个结果
            for i in range(n):
                res.append(''.join(board[i]))  #将棋盘每行转为一个string填入结果
            record.append(res)
        else:
            for col in range(n):
                if self.isValid(board, row, col, n):  #若合法则填入
                    board[row][col] = 'Q'
                    self.solve(record, board, row + 1, n)  #递归进入下一行
                    board[row][col] = '.'  #还原现场,回溯

    def isValid(self, board, row, col, n):  #判断row,col位置是否合法
        for i in range(n):
            if board[i][col] == 'Q':
                return False
        for i, j in zip(range(row - 1, -1, -1), range(col - 1, -1, -1)):
            if board[i][j] == 'Q':
                return False
        for i, j in zip(range(row - 1, -1, -1), range(col + 1, n)):
            if board[i][j] == 'Q':
                return False
        return True
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用ABT算法求解四皇后问题的Python代码: ``` def abt_search(csp): return abt_recursive(csp, {}) def abt_recursive(csp, assignment): if len(assignment) == len(csp.variables): return assignment var = select_unassigned_variable(csp, assignment) for value in order_domain_values(var, assignment, csp): if is_consistent(var, value, assignment, csp): csp.assign(var, value) inferences = {} for neighbor in csp.neighbors(var): if neighbor not in assignment: for removed_value in csp.curr_domain_values(neighbor): if not csp.constraints(var, value, neighbor, removed_value): inferences[neighbor] = removed_value csp.eliminate(neighbor, removed_value) result = abt_recursive(csp, assignment) if result is not None: return result csp.unassign(var) for neighbor, removed_value in inferences.items(): csp.revise(neighbor, removed_value) return None def select_unassigned_variable(csp, assignment): for var in csp.variables: if var not in assignment: return var def order_domain_values(var, assignment, csp): return csp.curr_domain_values(var) def is_consistent(var, value, assignment, csp): for neighbor in csp.neighbors(var): if neighbor in assignment: if not csp.constraints(var, value, neighbor, assignment[neighbor]): return False return True class CSP: def __init__(self, variables, domains, constraints): self.variables = variables self.domains = domains self.constraints = constraints self.unassigned_vars = set(variables) self.curr_domains = {v: set(domains) for v in variables} def assign(self, var, value): self.unassigned_vars.remove(var) self.curr_domains[var] = set([value]) def unassign(self, var): self.unassigned_vars.add(var) self.curr_domains[var] = set(self.domains) def eliminate(self, var, value): self.curr_domains[var].remove(value) def revise(self, var, value): self.curr_domains[var].add(value) def curr_domain_values(self, var): return self.curr_domains[var] def neighbors(self, var): return set(self.variables) - set([var]) def is_complete(self, assignment): return len(assignment) == len(self.variables) def four_queens_csp(): variables = ['Q1', 'Q2', 'Q3', 'Q4'] domains = range(1, 5) constraints = lambda Q1, Q2, Q3, Q4: (Q1 != Q2 and Q1 != Q3 and Q1 != Q4 and Q2 != Q3 and Q2 != Q4 and Q3 != Q4 and abs(Q1 - Q2) != 1 and abs(Q1 - Q3) != 2 and abs(Q1 - Q4) != 3 and abs(Q2 - Q3) != 1 and abs(Q2 - Q4) != 2 and abs(Q3 - Q4) != 1) return CSP(variables, domains, constraints) if __name__ == '__main__': csp = four_queens_csp() solution = abt_search(csp) if solution is not None: print(solution) else: print('No solution found') ``` 该代码定义了一个CSP类,其中包含“assign”、“unassign”、“eliminate”和“revise”等方法,用于实现ABT算法。它还定义了一个“four_queens_csp”函数,用于创建四皇后问题的CSP实例。最后,它调用“abt_search”函数来解决问题,并输出解决方案。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值