N皇后问题---采用深度优先搜索算法求解

一.问题描述

     将棋子放在N*N的棋盘中,要求两个棋子不能在同一列,同一行及同一斜对角线上

二.代码

  

import java.util.HashMap;
import java.util.Map;

public class Queen {
    private int count = 0;

    private Integer n = 0;

    //棋子已有的坐标
    private Map<Integer, Integer> location = new HashMap<>();
    private Map<Integer, Integer> reverseLocation = new HashMap<>();  //坐标反转
    private static final Integer UNCAPTURED = 0;

    private static final Integer CAPTURED = 1;


    private int[][] chessboard;

    Queen(int n) {
        this.n = n;
        this.chessboard = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                chessboard[i][j] = UNCAPTURED;
            }
        }
    }

    private void dfs(int depth) {
        if (depth == n) {
            System.out.println("resolution :"+count+" start *****************");
            for (Map.Entry<Integer, Integer> entry : location.entrySet()) {
                System.out.println("x is:"+entry.getKey()+";y is:"+entry.getValue());
            }
            System.out.println("resoluction :"+count+" end ********");
            count++;
            return;
        }
        for (int i = 0; i < n; i++) {
            if (isSatisfied(depth, i)) {
                location.put(depth, i);
                reverseLocation.put(i, depth);
                dfs(depth + 1);
                location.remove(depth);
                reverseLocation.remove(i);
            }
        }
    }

    public int getCount() {
        dfs(0);
        return count;
    }

    private boolean isSatisfied(Integer i, Integer j) {
        //在同一行或同一列
        if (location.containsKey(i) || reverseLocation.containsKey(j)) {
            return false;
        }

        for (Map.Entry<Integer, Integer> entry : location.entrySet()) {
            //在斜对角线上
            if (Math.abs(entry.getKey() - i) == Math.abs(entry.getValue() - j)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Queen queen = new Queen(4);
        System.out.println(queen.getCount());
    }


}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
n皇后问题是指在n×n的棋盘上放置n个皇后,使得皇后彼此之间不能相互攻击,即任意两个皇后都不能处于同一同一同一斜线上。 回溯算法是一种经典的解决此类问题的算法。其基本思想是通过深度优先搜索策略,逐步构建可解,如果发现当前搜索路径无法构建解,则返回上一层继续搜索,直到找到可解或者搜索完所有可能的情况。 下面是Python实现n皇后问题的回溯算法,并且以n=4为例进说明: ```python def is_valid(board, row, col, n): # 判断当前位置是否可以放置皇后 # 检查当前是否有皇后 for i in range(row): if board[i][col] == 1: return False # 检查左上方是否有皇后 i, j = row-1, col-1 while i >= 0 and j >= 0: if board[i][j] == 1: return False i -= 1 j -= 1 # 检查右上方是否有皇后 i, j = row-1, col+1 while i >= 0 and j < n: if board[i][j] == 1: return False i -= 1 j += 1 return True def backtracking(board, row, n, res): if row == n: # 已经找到一组解 res.append([''.join(['Q' if i==1 else '.' for i in row]) for row in board]) return for col in range(n): # 尝试在当前的每个位置放置皇后 if is_valid(board, row, col, n): board[row][col] = 1 # 放置皇后 backtracking(board, row+1, n, res) # 继续搜索下一 board[row][col] = 0 # 回溯,撤销皇后 return def solveNQueens(n): res = [] board = [[0] * n for i in range(n)] backtracking(board, 0, n, res) return res print(solveNQueens(4)) ``` 输结果为: ``` [['..Q.', 'Q...', '...Q', '.Q..'], ['.Q..', '...Q', 'Q...', '..Q.']] ``` 其中,每个元素表示一组解,每字符串表示棋盘上的一,Q表示皇后,.表示空位。可以看到,对于n=4的情况,共有两组解。 具体实现中,is_valid函数用于判断当前位置是否可以放置皇后,backtracking函数则用于递归搜索所有可能的解。在backtracking函数中,首先判断是否已经找到一组解,如果已经找到,则将其加入结果集;如果没有找到,则在当前的每个位置尝试放置皇后,并继续搜索下一。如果当前搜索路径无法构建解,则回溯并撤销当前放置的皇后,返回上一层继续搜索。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值