51. N-Queens

题目描述(苦难难度)

在这里插入图片描述
经典的 N 皇后问题。意思就是摆皇后的位置,每行每列以及对角线只能出现 1 个皇后。输出所有的情况。

解法一 回溯法

比较经典的回溯问题了,我们按列来放置皇后,我们需要做的就是先在第一列的某个位置放一个皇后,接着在第二列的某个位置放置皇后,如果在后面出现不满足的情况,则进入回溯,重新调整放入的位置,一直走下去,如果已经放的皇后的数目等于 n 了,就加到最后的结果中。然后再回到上一行,变化皇后的位置,然后去找其他的解。

期间如果遇到当前行所有的位置都不能放皇后了,就再回到上一行,然后变化皇后的位置。再返回到下一行。

说起来可能还费力些,直接看代码吧。


import java.util.*;

public class N_Queens {

    public static List<List<String>> solveNQueens(int n){
        char[][]board=new char[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                board[i][j]='.';
            }
        }
        List<List<String>> res = new ArrayList<List<String>>();
        dfs(board,0,res);
        return res;
    }
    private static void dfs(char[][]board,int colIndex,List<List<String>>res){

        if(colIndex==board.length){
            res.add(construct(board));
            return;
        }

        for(int i=0;i<board.length;i++){
            if(validate(board,i,colIndex)){
                board[i][colIndex]='Q';
                dfs(board,colIndex+1,res);
                board[i][colIndex]='.';
            }
        }
    }
    private static boolean validate(char[][]board,int x,int y){
        for(int i=0;i<board.length;i++){
            for(int j=0;j<y;j++){
                if(board[i][j]=='Q' &&(x+j==y+i||x+y==i+j || x==i))
                    return false;
            }
        }
        return true;
    }
    private static List<String> construct(char[][]board){
        List<String> res =new LinkedList<String>();
        for(int i=0;i<board.length;i++){
            String s=new String(board[i]);
            res.add(s);
        }
        return res;
    }

    public static void main(String args[]){
        int n =4;
        List<List<String>> ans =solveNQueens(n);
        System.out.println(ans);
    }
}

参考文献

  • https://leetcode.com/problems/n-queens/discuss/19805/My-easy-understanding-Java-Solution
  • 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
发出的红包

打赏作者

安替-AnTi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值