用递归思想和回溯算法解决八皇后问题(java实现)

八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

问题介绍

八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n1×n1，而皇后个数也变成n2。而且仅当 n2 ≥ 1 或 n1 ≥ 4 时问题有解。
八皇后问题最早是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出。之后陆续有数学家对其进行研究，其中包括高斯和康托，并且将其推广为更一般的n皇后摆放问题。八皇后问题的第一个解是在1850年由弗朗兹·诺克给出的。诺克也是首先将问题推广到更一般的n皇后摆放问题的人之一。1874年，S.冈德尔提出了一个通过行列式来求解的方法，这个方法后来又被J.W.L.格莱舍加以改进。
艾兹格·迪杰斯特拉在1972年用这个问题为例来说明他所谓结构性编程的能力。
八皇后问题出现在1990年代初期的著名电子游戏第七访客中。

问题解决。

第一种：

也是最笨的方法，就是定义8个for循环。。。。

第二种：回溯算法

代码实现

public class Queen {
    private int[] column; //同栏是否有皇后，1表示有
    private int[] rup; //右上至左下是否有皇后
    private int[] lup; //左上至右下是否有皇后
    private int[] queen; //解答
    private int num; //解答编号
 
    public Queen() {
        column = new int[8+1];
        rup = new int[(2*8)+1];
        lup = new int[(2*8)+1];
        for (int i = 1; i <= 8; i++)
            column[i] = 0;
        for (int i = 1; i <= (2*8); i++)
            rup[i] = lup[i] = 0;  //初始定义全部无皇后
        queen = new int[8+1];
    }
 
    public void backtrack(int i) {
        if (i > 8) {
            showAnswer();
        } else {
            for (int j = 1; j <= 8; j++) {
                if ((column[j] == 0) && (rup[i+j] == 0) && (lup[i-j+8] == 0)) {
                    //若无皇后
                    queen[i] = j; //设定为占用
                    column[j] = rup[i+j] = lup[i-j+8] = 1;
                    backtrack(i+1);  //循环调用
                    column[j] = rup[i+j] = lup[i-j+8] = 0;
                }
            }
        }
    }
 
    protected void showAnswer() {
        num++;
        System.out.println("\n解答" + num);
        for (int y = 1; y <= 8; y++) {
            for (int x = 1; x <= 8; x++) {
                if(queen[y]==x) {
                    System.out.print("Q");
                } else {
                    System.out.print(".");
                }
            }
            System.out.println();
        }
    }
 
    public static void main(String[] args) {
        Queen queen = new Queen();
        queen.backtrack(1);
    }
}

第三种：递归调用

代码实现

package p03.递归;

/*
 * 第1行
 * 		1
 * 		第2行
 * 			3
 * 			第3行
 * 				5
 * 				第4行
 * 					2	X
 * 					第5行
 * 						4	X
 * 						第6行
 * 							X
 * 						8	X
 * 						第6行
 * 							X
 * 					7
 * 					第5行
 * 						2	X
 * 						第6行	X
 * 							4	X
 * 							第7行
 * 								6	X
 * 								第8行
 * 									X
 * 						4
 * 						...
 * 						
 * 					8
 * 				6
 *				7
 *				8
 * 			4
 * 			5
 * 			6
 * 			7
 * 			8
 * 		2
 * 		3
 * 		4
 * 		5
 * 		6
 * 		7
 * 		8
 * */
public class EightQueen {
	private static int count=0;	//记录第几种可能
	private static int N=8;
	public static void main(String[] args) {
		int[][] arr=new int[N][N];	//默认元素为0 1当皇后
		eightQueen(0,arr);	//打印八皇后所有可能的解 并且从第一行开始 0
	}
	//row [0,7]
	private static void eightQueen(int row, int[][] arr) {
		if(row==N){//打印条件，假设是8皇后，每次走到第9行时就打印。
			count++;
			System.out.println("第"+count+"种：");
			for(int i=0;i<arr.length;i++){
				for(int j=0;j<arr[i].length;j++){
					System.out.print(arr[i][j]+" ");
				}
				System.out.println();
			}
		}else{
			//做一个数组备份
			int[][] newArr=new int[N][N];
			for(int i=0;i<arr.length;i++){
				for(int j=0;j<arr[i].length;j++){
					newArr[i][j]=arr[i][j];
				}
			}
			for(int col=0;col<N;col++){
			/*
			判断当前元素的上，左上，右上是否有皇后。
			*/
				if(noDangerous(row,col,newArr)){
					for(int c=0;c<N;c++){
						newArr[row][c]=0;//将当前行的其他位置的皇后置为0
					}
					newArr[row][col]=1;
					eightQueen(row+1, newArr);
				}
			}
		}	
	}
	private static boolean noDangerous(int row, int col, int[][] newArr) {
		//正上
		for(int r=row-1;r>=0;r--){
			if(newArr[r][col]==1){
				return false;
			}
		}
		//左上
		for(int r=row-1,c=col-1;r>=0&&c>=0;r--,c--){
			if(newArr[r][c]==1){
				return false;
			}
		}
		//右上
		for(int r=row-1,c=col+1;r>=0&&c<N;r--,c++){
			if(newArr[r][c]==1){
				return false;
			}
		}
		return true;
	}
}

执行结果