回溯算法之N皇后问题(java实现)

逗逼室友说了:

回溯是思想,深搜是本质,递归是实现。

 在理!

 

虽不是第一次接触递归,但是确实实实在在的第一次接触回溯。是琢磨了蛮长时间才编完并测试通过的代码,继承本菜鸟一贯简单的作风,希望能给不太熟悉回溯思想的各位看官一点启发。但是大家在学习回溯时,还是需要明白递归的思想的。不废话

 

八皇后问题是回溯思想的经典题目,就好像由汉诺塔引入递归一样。具体的要求就不再啰嗦了,google一下一大片(这里给出leetcode中的n皇后的题目大意http://oj.leetcode.com/problems/n-queens/)题目大意:8*8棋盘,8个皇后,怎么放才能保证这几个皇后和谐相处,互不干涉。

 

算法思想:(为了通俗易懂,本文从1开始计数)

0. 将皇后编号1,2,3,4,5,6,7,8,并且排号为i的皇后,放在第i行

1. 将1号皇后放在第1行(1号皇后是肯定不会冲突的)

2. 1号皇后放好之后,放2号皇后(3号及以后的类似),从第2行第1列开始检测,不冲突就可以落子; 当本行没有合法的位置时,说明上一行皇后放的位置不好,则撤销上一行皇后的位置,并重新摆放(所谓回溯)

3. 如果8个皇后放好之后,按照上文逻辑该放8 + 1 号皇后了,但是已经放完了,所以将摆放结果打印。再重新摆放第8行(很多人不理解这里为什么还回溯)

 

回溯发生的位置:

1. 皇后i的摆放位置,使得皇后i+1怎么放都不行,即这条路走不通了,回溯(重新摆放皇后i的位置,使得i+1可以摆放,就好像迷宫遇到墙了,要往回走)

2. 8个皇后都摆放完毕,打印出了摆放结果,回溯(就好像迷宫找到了一件宝物(一共需要集齐n件),你找到之后还要回头找另外几件,直到你集齐或者把所有的路都走了(DFS))

 

算法小结:

1. 对第 i 个皇后,从第i行第1列到第8列,逐个查找,看是否有不冲突的安全位置(特殊情况,皇后1)

2. 如果冲突了,就检查下一列,直到安全的位置,找到最后都不安全,回溯(去找合法序列);

3. 最后一个皇后摆放成功,回溯(去找别的可能性)

 

public class NQueens {
	private static int queenNum;//皇后的个数
	private static int[] hash;//下标表示i号皇后(皇后i放在第i行)value表示放的列号
	private static int count = 0;//合法摆放方式的个数

	public void placeQueen(int m) {
		if (m > queenNum) {//如果摆到了n+1行了,说明前n行都是不冲突的,合法的
			count++;
			System.out.println(Arrays.toString(hash));
                        //打印合法的摆放结果
			for(int i = 1; i <= queenNum; i++){
				int column = hash[i];//hash值表示皇后i所在的列号
				for(int j = 1; j <= queenNum ;j++){
					if(j!= column){
						System.out.print("* ");
					}else{
						System.out.print("Q ");
					}
				}
				System.out.println();
			}
			return;
		}
		for (int i = 1; i <= queenNum; i++) {
		//check the column is conflict with former ones or not
		//if so, check the next column until find a non-conflict column 
                //or until the last column ,return;
			if (isConfilct(m, i)) { 
				continue;
			} else {//如果检测到第i列不冲突,是安全的,
				hash[m] = i;//将皇后m放在第i列
				placeQueen(m + 1);//再放皇后m+1,
				//如果皇后m+1放完并返回了
				//两种可能:
				//1:冲突,返回了
				//2.一直将所有的皇后全部放完并安全返回了
				//将皇后m回溯,探索新的可能或者安全的位置
                  hash[m] = -1;
				//其实这里没必要将m重新赋值的,因为检测到下一个
				//安全位置的时候会把hash[m]覆盖掉的
				//但是为了更好的体现“回溯”的思想,在这里画蛇添足了
			}
		}
	}

	/**
	 * 检测冲突
	 * @param index
	 *            表示行号
	 * @param hash
	 *            值表示列号
	 * @return
	 */
	private boolean isConfilct(int row, int column) {
		if(row == 1){//第1行永远不会冲突
			return false;
		}
		//只需要保证与那些已经就位的皇后不冲突即可
		for (int i = 1; i < row; i++) {
			if (hash[i] == column || ( column - row) == (hash[i] - i) || (row - column)== (i-hash[i]) 
				|| (row + column) == (hash[i] + i)) {
				return true;
			}
		}
		return false;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		queenNum = sc.nextInt();
		hash = new int[queenNum + 1];
		for (int i = 0; i < hash.length; hash[i++] = -1);//初始化棋盘
		NQueens demo = new NQueens();
		demo.placeQueen(1);
		System.out.println(count);
	}
}

 

我取的queenNum = 4时,打印出来的结果是 

4 //hash从1开始计数,第0位没有意义,hash[row] = column 表示row号皇后放在第row行,第column列
[-1, 2, 4, 1, 3] //比如hash[1]= 2表示1号皇后在第1行第2列
* Q * *
* * * Q
Q * * *
* * Q *
[-1, 3, 1, 4, 2]
* * Q *
Q * * *
* * * Q
* Q * *
2

 

你可能感兴趣的:(java实现)