Java编程思想—八皇后问题（数组法、堆栈法）

实验题目：回溯法实验(八皇后问题)

实验目的：

（1） 掌握回溯法求解问题的思想
（2） 学会利用其原理求解相关问题

实验要求：

	使用贪心法求出给定图各点的最短路径，并计算算法的执行时间，分析算法的有效性。利用回溯法解决八皇后问题，检验结果，并计算算法的执行时间，分析算法的有效性。 
	测试数据可以通过手工寻找三组满足需要的值，测试数组（M，N），其中 M 代表皇后所在的行，N 代表皇后所在的列。

例如，第一组测试数据：
（1，4）、（2，7）、（3，3）、（4、8）、（5，2）、（6，5）、（7，1）、 （8，6）；
第二组测试数据
（1，5）、（2，2）、（3，4）、（4，7）、（5，3）、（6，8）、（7，6）、 （8，1）；
第三组测试数据
（1，4）、（2，2）、（3，7）、（4，3）、（5，6）、（6，8）、（7，5）、 （8，1）。
最后与编程求得的结果进行比较。如果这三组数据在最后编程求得的结果中，说明程序的编写基本没有什么问题。

实验内容：

（1）问题描述

八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后。为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。

（2）实验步骤：

数组法：

① 根据 8 皇后问题，可以把其设想为一个数组；
② 根据 8 皇后的规则，可以设想为数组上同一直线，横线，斜线的数字都不能相同，由此可以得出判断条件；
③ 根据判断条件之后，建立回溯点，即可解决问题。

堆栈法：

① 检索当前行是否可以放置一个皇后；
② 利用检索过程，通过递归的方式，来确定每个皇后的位置———回溯的思想。

算法伪代码：

实验结果：

实验代码：

public class EightQueensOfBacktracking {
	int count = 0;
	//棋盘初始化 清空操作
	void initialChessBoard(int chessBoard[][]){
		for(int i = 0; i < 8 ; i++){
			for(int j = 0; j < 8; j++){
				chessBoard[i][j] = 0;
			}
		}
	}
	//打印皇后位置
	void showLocation(int chessBoard[][]){
		System.out.println("————————————");
		System.out.println("皇后的坐标为：");
		for(int i = 0; i < 8 ; i++){
			for(int j = 0; j < 8; j++){
				if(chessBoard[i][j] != 0){
					System.out.print(" ( " + (i+1) + " , " + (j+1) + " ) ");
				}
			}
		}
		System.out.println();
		System.out.println("棋盘如下：");
		for(int i = 0; i < 8 ; i++){
			for(int j = 0; j < 8; j++){
				System.out.print(chessBoard[i][j] + " ");
			}
			System.out.println();
		}
	}
	//行列检查 斜线检查
	boolean checkAll(int i, int j, int chessBoard[][]){
		int tempI = i;
		int tempJ = j;
		if((i>7)||(j>7)) return false;
		//check column
		for(int k = 0; k <= j; k++){
			if(chessBoard[i][k] != 0){
				return false;
			}
		}
		//check row
		for(int k = 0; k <= i; k++){
			if(chessBoard[k][j] != 0){
				return false;
			}
		}
		//左上斜线检查
		while(true){
			if(chessBoard[i][j] != 0)
				return false;
			if((i == 0)||(j == 0)) break;
			i--;
			j--;
		}
		//右上斜线检查
		i = tempI;
		j = tempJ;
		while(true){
			if(chessBoard[i][j] != 0)
				return false;
			if((i == 0)||(j == 7)) break;
			i--;
			j++;
		}
		return true;
	}
	
	//堆栈方法
	public void findQueen(int i, int chessBoard[][], EightQueensOfBacktracking eightQueens){
		if(i>7){
			eightQueens.count++;
			eightQueens.showLocation(chessBoard);
		}
		//回溯法
		boolean judge; 
		for(int m = 0; m<8; m++){
			judge = eightQueens.checkAll(i, m, chessBoard);
			if(judge){
				chessBoard[i][m] = 1;
				eightQueens.findQueen(i+1, chessBoard, eightQueens);
				chessBoard[i][m] = 0;
			}
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//函数调用
		EightQueensOfBacktracking eightQueens = new EightQueensOfBacktracking();
		//摆法的数量
		int count = 0;
		int k = 0;//临时变量
		int i = 0, j= 0;//i 行 ；j 列
		boolean judge = true;//检查结果
		//8个皇后，1-8表示
		int queens = 1;
		//棋盘 8*8 
		int chessBoard[][] = new int [8][8];
		//每次找到解后清盘，即初始化
		eightQueens.initialChessBoard(chessBoard);
		
		long startTime2 = System.nanoTime();
		//堆栈方法：
		eightQueens.findQueen(0, chessBoard, eightQueens);
		long endTime2 = System.nanoTime();
		
		
		//数组方法
		//失败1：在当前行非末尾：列+1；
		//失败2：在当前行的末尾：判断行，如果是0行，则所有情况已遍历，结束；
//													如果不是，回到上一行，遍历，查找到上一行的棋子，记录位置，找到下一位置，则结束查找上一个位置；
//															如果上一行也遍历完，列的位置为7，上一个位置处没有下一位置，则再找上上一行的位置，进行上面的循环；
//																	如果上一行是0行，则也结束遍历，flag为0，结束上一位置的查找；
													
		//成功：标记位置，如果位置标记是8，则为一种方案，输出，方法计数加一，标记减1，queens表示下一个要放的棋子；
//					行加1，列归0，通过失败1和失败2再找到上一个棋子的的位置
		long startTime1 = System.nanoTime();
		int flag = 1;
		while(true){
			judge = eightQueens.checkAll(i, j, chessBoard);
			//这一行未检查完，检查这一行下一个位置
			if((judge == false)&&(j != 7)){
				j++;
				continue;
			}
			else if((judge == false)&&(j == 7)){
				if(i == 0) break;//表示所有的情况已经遍历，结束循环
				i--;//回到上一行
				k = 0;//查找，用来遍历
				while(true){
					if(chessBoard[i][k] != 0){//找到上一行棋子的位置
						queens = chessBoard[i][k];//表示这个棋子放到棋盒中
						chessBoard[i][k] = 0;//把棋子取走
						j = k + 1;//找到下一个位置，准备下一次循环
						if(j > 7){//如果上一行也遍历完，找到上上一行
							if(i == 0){
								flag = 0;
								break;//如果上一行是0，那么没有上上一行，结束
							}
							i--;
							k =0;
							continue;//重新开始查找棋子
						}
						break;
					}
					k++;
				}
				if(flag == 0){
					break;
				}
				continue;
			}
			//检查通过，放下棋子，到下一行
			chessBoard[i][j] = queens;
			if(queens == 8){//找到一种方法
				eightQueens.showLocation(chessBoard);
				count++;
				queens--;
				//输出后，假装这个摆法不行，继续查找
			}
			queens++;//queens的值表示下一个要放的棋子
			i++;
			j = 0;
			
		}
		long endTime1 = System.nanoTime();
		System.out.println("数组方法共有" + count + "种摆法");
		System.out.println("堆栈递归方法共有" + eightQueens.count + "种摆法");
		System.out.println("数组程序运行时间：" + (endTime1 - startTime1) + "ns");
		System.out.println("堆栈递归程序运行时间：" + (endTime2 - startTime2) + "ns");
	}

}

出现的问题：

问题一：条件检查

实验时，排序的结果出现问题，斜线的情况不能检查出来。

于是我仔细检查了判断部分的代码，发现是变量的重复使用，导致无法正常判断。i和j的值被重复使用。我通过临时变量进行存储，在上一次使用后进行重新赋值，解决了问题，如红圈。

问题二：数组法 跳出循环情况分析

一开始不知道递归方法，想用情况分析，循环查找，但是发现在查找时，只能查找到第一个棋子在1，1位置的情况。

我猜测是跳出循环的判断出了问题，于是在我的检查下，发现下图第一个圈是要跳出循环，结束整个查找，由于是双重循环，所以我直接在第二个圈设置如果i= =0，则结束循环，共两次跳出。

但是我忽略了限制条件，即在i = = 0的时候，并不是都是要结束的，只有圈1的那一种情况才跳出，所以我设置flag变量进行传递，纠正了程序的错误。 更正的代码 见 实验代码 部分。

实验心得：

本次实验体现的是回溯法。经过本次实验，发现自己对回溯的理解并不全面，不会应用。初次做这个题，想的只是遍历，在循环中，进行人工的回溯。后来发现回溯时的情况分析十分复杂，并不能很好的发现并且处理所有情况，只求出4种结果。经过学习后了解到，对于回溯，本题不需要自己考虑情况，只需给出限制条件进行筛选，在满足条件的情况下进行重复调用自身函数，在完成函数后，进行自身位置的值的清空，为之后回溯进行准备即可。让我明白递归是回溯的一种很好的实现方式。
在使用java的过程中，为了解决遇到的问题还进行了调试，让我对debug和调试有了进一步的掌握。
说明：递归法是调用系统堆栈进行操作，所以属于堆栈法。

递归堆栈方法可以参考链接：八皇后递归堆栈方法