回溯算法经典应用之—N皇后问题 (Java)

1、回溯算法简介

回溯算法也叫试探法,它是一种系统地搜索问题的解的方法。回溯算法的基本思想是:从一条路往前走,能进则进,不能进则退回来,换一条路再试。用回溯算法解决问题的一般步骤为:
1)、定义一个解空间,它包含问题的解。
2)、利用适于搜索的方法组织解空间。
3)、利用深度优先法搜索解空间。
4)、利用限界函数避免移动到不可能产生解的子空间。
问题的解空间通常是在搜索问题的解的过程中动态产生的,这是回溯算法的一个重要特性。


2、N皇后问题定义

在n×n格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。


如图所示为8皇后问题。

思路:   用数组x[n]表示n后问题的解。

其中,x[i]表示皇后i放置在棋盘的第i行的第x[i]列。由于不容许将2个皇后放在同一列上,所以解向量中的x[i]互不相同。2个皇后不能放在同一斜线上是问题的隐约束。对于一般的n后问题,这一隐约束条件可以化成显约束的形式。如果将n*n 格的棋盘看做二维方阵,其行号从上到下,列号从左到右依次编号为1,2,...n。从棋盘左上角到右下角的主对角线及其平行线(即斜率为-1的各斜线)上,2个下标值的差(行号-列号)值相等。同理,斜率为+1的每条斜线上,2个下标值的和(行号+列号)值相等。因此,若2个皇后放置的位置分别是(i,j)和(k,l),且 i-j = k -l 或 i+j = k+l,则说明这2个皇后处于同一斜线上。以上2个方程分别等价于i-k = j-l 和 i-k =l-j。由此可知,只要|i-k|=|l-j|成立,就表明2个皇后位于同一条斜线上。

解题步骤
1)、从空棋盘起,逐行放置棋子。
2)、每在一个布局中放下一个棋子,即推演到一个新的布局。
3)、如果当前行上没有可合法放置棋子的位置,则回溯到上一行,重新布放上一行的棋子。



3、Java代码实现

package com.qian.backtracing;
/**
 * 
 * n 皇后问题
 * 在n×n格的国际象棋上摆放八个皇后,使其不能互相攻击,
 * 即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
 * @author QHF
 *
 */
public class NQuene {
	private static final int N = 4;
	private int[] x = new int[N];
	
	int sum  = 0;
	/**
	 * 回溯寻找
	 * 
	 * @param n
	 */
	void backTack(int n) {
		

		
		if(n == N) {
			for (int i = 0; i < x.length; i++) {
				System.out.print("x["+i+"] = " +x[i] + ",");
			}
			System.out.println();
			sum ++;
		}
		else {
			for (int i = 0; i < N; i++) {
				x[n] = i;
				if(isPlace(n)) {//如果第n行可以放,继续看n + 1行
					backTack(n + 1);
				}
			}
		}
	}
	/**
	 * 在i行可否放置皇后   0 <= i <= n
	 * @param i
	 * @return
	 */
	private boolean isPlace(int i) {
		
		for (int j = 0; j < i; j++) {
			if(Math.abs(i - j) == Math.abs(x[i] - x[j])  || x[i] == x[j])  {
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		NQuene quene = new NQuene();
		
		quene.backTack(0);
		
		System.out.println(quene.sum);
		
	}
	
	
	
	
}


不同数量皇后只需要修改N的值就可以了。


这里给出一种当N= 4的时候的输出:

x[0] = 1,x[1] = 3,x[2] = 0,x[3] = 2,
x[0] = 2,x[1] = 0,x[2] = 3,x[3] = 1,
2






  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
n皇后问题是一个经典回溯算法问题,它的目标是在一个n×n的棋盘上放置n个皇后,使得每个皇后都不会互相攻击,即任意两个皇后都不在同一行、同一列和同一条对角线上。下面是Java语言实现n皇后问题的代码: ```java public class NQueens { private int[] queens; // 存放每行皇后所在的列数 private boolean[] rows; // 标记每行是否有皇后 private boolean[] diagonal1; // 标记正对角线是否有皇后 private boolean[] diagonal2; // 标记反对角线是否有皇后 private List<List<String>> result; // 存放所有合法的棋盘布局 public List<List<String>> solveNQueens(int n) { queens = new int[n]; rows = new boolean[n]; diagonal1 = new boolean[2 * n - 1]; diagonal2 = new boolean[2 * n - 1]; result = new ArrayList<>(); backtrack(0, n); return result; } private void backtrack(int row, int n) { if (row == n) { // 找到一组合法的棋盘布局 List<String> board = new ArrayList<>(); for (int i = 0; i < n; i++) { char[] rowChars = new char[n]; Arrays.fill(rowChars, '.'); rowChars[queens[i]] = 'Q'; board.add(new String(rowChars)); } result.add(board); } else { for (int col = 0; col < n; col++) { // 枚举当前行皇后可以放置的列数 if (rows[row] || diagonal1[row + col] || diagonal2[row - col + n - 1]) { continue; // 如果当前位置不合法,直接跳过 } queens[row] = col; rows[row] = true; diagonal1[row + col] = true; diagonal2[row - col + n - 1] = true; backtrack(row + 1, n); // 继续放置下一行的皇后 queens[row] = 0; rows[row] = false; diagonal1[row + col] = false; diagonal2[row - col + n - 1] = false; } } } } ``` 该算法的时间复杂度为O(n^n),因为每个皇后都有n个选择,总共有n个皇后,所以时间复杂度为n^n。在实际应用中,n的范围比较小,该算法的效率是可以接受的。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值