回溯法解决2n皇后(8皇后)问题

8皇后问题是算法入门的经典,在8*8的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一

行,同一列,或者同一斜线上。关于8皇后的解法请见:http://www.cnblogs.com/newflydd/p/5091646.html


今天要说的2n皇后问题与传统的8皇后问题有些不同,在一个n*n的棋盘中,有些位置不允许放皇后,现在要向棋盘中

放入n个黑皇后和n个白皇后,使任意的两个黑白皇后都不在同一行,同一列或者同一条对角线上。看起来问题变得有

些复杂了,但其实本质上还是8皇后问题。


我们使用回溯算法和递归的思想来解决这个问题。每行只能放置一个黑皇后和一个白皇后,从第一行第一列开始放

置,假设第一行第一列放置白皇后,那么黑皇后在第一排的位置就还有n-1中可能,依次检测每一种可能性,首先将

黑皇后放在第一排第二列的位置。然后放置第二排,在放第二排时就需要考虑到皇后的摆放规则,打个比方说在第二

排第一列放一个白皇后,那么此时就需要进行检测,白皇后的位置是否安全可行,明显的一列只能放一个白皇后,所

以这个皇后的摆放位置不可行,重新摆放,在重新摆放之前会清除本行原本的摆放记录。当这一排的所有位置都不能

安全的摆放两个皇后时,就需要退回到上一行的摆放,清楚上一行原本的摆放记录,重新摆放。

直到第一次摆放到最后一行,并且棋盘中的黑白皇后数量正确,此时才算是得出了一个正解。到这里程序并不会结

束,因为得到一个正解并不等于尝试完所有的可能性,程序只有在尝试完所有的可能摆放皇后位置以后,才会结束。


了解算法的思路以后代码的框架也就出来了,用一个二维数组模拟棋盘,默认值为0和1,0即为此位置不可以摆放皇

后,在摆放皇后时也需要对此进行验证,这里我们用6代表白皇后,9代表黑皇后,放置皇后也就是改变数组中指定位

置的数值。在验证摆放皇后位置是否可行时,需要判断三个方向是否有该种皇后,即两条对角线和本列,而且只需要

考虑皇后所在行的上面,因为下面还没有摆放皇后啊!为了便于处理,将棋盘分为三部分(除去第一行,第一行不需

要判断),第一部分为第一列,第二部分为最后一列,第三部分为其他列。这样分第一部分和第二部分只需要考虑一

条对角线,只有第三部分需要考虑两条。


import java.util.Scanner;

public class Demo4 {

	private static int result = 0;
	

	public static boolean isSafety(short[][] chess, int row, int x, int queen) {
		
		if (row != 0 && x != 0 && x != chess.length - 1) {
			
			int step=1,step2=1;
			while(row-step>=0&&x+step<=chess.length-1){
				if(chess[row-step][x+step]==queen){
					return false;	
				}
				step++;
			}
			while(row-step2>=0&&x-step2>=0){
				if(chess[row-step2][x-step2]==queen){
					return false;	
				}
				step2++;
			}
		}
	
		if (row != 0 && x == 0) {
			int step=1;
			while(row-step>=0&&x+step<=chess.length-1){
				if(chess[row-step][x+step]==queen){
					return false;	
				}
				step++;
			}
		}

		if (row != 0 && x == chess.length-1) {
			int step=1;
			while(row-step>=0&&x-step>=0){
				if(chess[row-step][x-step]==queen){
					return false;	
				}
				step++;
			}
		}

		for (int i = 0; i < row; i++) {
			if (chess[i][x] == queen) {
				return false;	
			}
		}

		return true;
	}

	public static void putQueen(short[][] chess, int row) {

		// 摆完一盘
		if (row == chess.length) {
			if(queenNumber(chess)){
				result++;
			}	
			return;
		}

		for (int i = 0; i < chess.length; i++) {
			//清除原本的摆放记录
			for (int j = 0; j < chess.length; j++) {
				if(chess[row][j]!=0){
					chess[row][j] = 1;
				}
			}

			if (isSafety(chess, row, i, 6)&&chess[row][i]==1) {
				//摆放白皇后
				chess[row][i] = 6;

				for (int k = 0; k < chess.length; k++) {
					//清除原本的摆放记录
					for (int l = 0; l < chess.length; l++) {
						if (chess[row][l] != 0 && l != i) {
							chess[row][l] = 1;
						}
					}

					if (isSafety(chess, row, k, 9)&&chess[row][k]==1&&k != i) {
						//摆放黑皇后
						chess[row][k]=9;
						//摆放下一行
						putQueen(chess, row + 1);

					}
				}
			}
		}

	}

	public static boolean queenNumber(short[][] chess){
		int white=0,black=0;
		for(int i=0;i<chess.length;i++){
			for(int j=0;j<chess.length;j++){
				if(chess[i][j]==6){
					white++;
				}
				if(chess[i][j]==9){
					black++;
				}
				
			}
		}
		if(white==chess.length&&black==chess.length){
			return true;
		}
		return false;
	}

	public static void main(String[] args) {
		Scanner console = new Scanner(System.in);
		int n = console.nextInt();
		short[][] chess = new short[n][n];

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				chess[i][j] = (short) console.nextInt();
			}
		}

		putQueen(chess, 0);
		System.out.println(result);

	}
}

控制台Sample:

4
1 0 1 1 
1 1 1 1
1 1 1 1
1 1 1 1
0


    原文作者:回溯法
    原文地址: https://blog.csdn.net/bazingaea/article/details/54894081
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞