算法--回溯Back Tracking（十七）

以下是学习恋上数据结构与算法的记录，本篇主要内容是回溯Back Tracking

回溯（Back Tracking）

回溯可以理解为：通过选择不同的岔路口来通往目的地（找到想要的结果）
每一步都选择一条路出发，能进则进，不能进则退回上一步（回溯），换一条路再试

树、图的深度优先搜索（DFS）、八皇后、走迷宫都是典型的回溯应用
不难看出来，回溯很适合使用递归

练习–八皇后问题（Eight Queens）
在8x8格的国际象棋上摆放八个皇后，使其不能互相攻击：任意两个皇后都不能处于同一行、同一列、同一斜线上，请问有多少种摆法？
八皇后问题的解决思路
思路一：暴力出奇迹：从64 个格子中选出任意8个格子摆放皇后，检查每一种摆法的可行性，一共C648种摆法（大概是4.4∗109种摆法）

思路二：根据题意减小暴力程度，很显然，每一行只能放一个皇后，所以共有88种摆法（16777216 种），检查每一种摆法的可行性

思路三：回溯法：回溯+ 剪枝

四皇后–回溯法
在解决八皇后问题之前，可以先缩小数据规模，看看如何解决四皇后问题

四皇后–剪枝（Pruning）

八皇后–回溯法模拟
可以看到发现摆法不了后，这里回溯到了上一层（第一次回溯）
结合上面，这个也不能摆放，上一层的两个选择都不行，就只能回溯到上两层，继续寻找
八皇后实现

/*
	 * 数组索引是行号、数组元素是列号
	 */
	int[] cols;
	/*
	 * 一共多少中摆法
	 */
	int ways;
	
	void placeQueens(int n){//N皇后
		if(n<1) return;
		cols =new int[n];
		place(0);//从第一层开始
		System.out.println(n + "皇后一共有" + ways + "种摆法");
	}
	
	/*
	 * 从第row行开始摆放
	 */
	void place(int row) {
		if(row == cols.length) {//如果是八皇后，cols.length为8，相等证明成功找到一种摆法
			ways++;
			show();
			return;
		}
		for(int col = 0;col<cols.length;col++) {
			if(isValid(row, col)) {//调用检查方法，是否可以摆放
				// 在第row行第col列摆放皇后
				cols[row] = col;
				place(row+1);
			}
			//回溯
			//上面方法执行过后，自带回溯效果，不需要还原现场，因为clos数组在row索引的值会被下一次覆盖掉，如上面实例图片的第一次回溯，所以不需要重新cols[row]清零
		}
	}
	
	/**
	 * 判断第row行第col列是否可以摆放皇后
	 */
	boolean isValid(int row, int col) {
	    //剪枝
		for(int i = 0;i<row;i++) {
			// 第col列已经有皇后
			if(cols[i] == col) {
				System.out.println("[" + row + "][" + col + "]=false");
				return false;
			}
			// 第i行的皇后跟第row行第col列格子处在同一斜线上，
			//同一斜线数学上有：
//			\这样的斜的如果同一对角线，那么x1-y1=x2-y2;
//          /这样的斜线，同一对角线，那么x1+y1=x2+y2;
			if(row - i == Math.abs(col -cols[i])) {
				System.out.println("[" + row + "][" + col + "]=false");
				return false;
			}
		}
		System.out.println("[" + row + "][" + col + "]=true");
		return true;
		
	}
	//输出打印
	void show() {
		for (int row = 0; row < cols.length; row++) {
			for (int col = 0; col < cols.length; col++) {
				if (cols[row] == col) {
					System.out.print("1 ");
				} else {
					System.out.print("0 ");
				}
			}
			System.out.println();
		}
		System.out.println("------------------------------");
	}

八皇后优化
优化的思路是利用成员变量Boolean值，减少判断次数

/**
	 * 数组索引是行号，数组元素是列号
	 */
	int[] queens;//在优化中，该数组只为方便输出打印
	/**
	 * 标记着某一列是否有皇后
	 */
	boolean[] cols;
	/**
	 * 标记着某一斜线上是否有皇后（左上角 -> 右下角）
	 */
	boolean[] leftTop;
	/**
	 * 标记着某一斜线上是否有皇后（右上角 -> 左下角）
	 */
	boolean[] rightTop;
	/**
	 * 一共有多少种摆法
	 */
	int ways;
	
	void placeQueens(int n) {
		if(n<1) return;
		queens = new int[n];
		cols = new boolean[n];
		leftTop = new boolean[(n<<1)-1];//对角线2n-1条
		rightTop = new boolean[leftTop.length];
		place(0);
		System.out.println(n + "皇后一共有" + ways + "种摆法");
	}
	/**
	 * 从第row行开始摆放皇后
	 * @param row
	 */
	void place(int row) {
		if(row == cols.length) {
			ways++;
			show();
			return;
		}
		for(int col = 0; col<cols.length;col++) {
		    //为true，则证明不能摆放
			if(cols[col]) continue;
			int ltIndex = row - col + cols.length -1;
			if(leftTop[ltIndex]) continue;
			int rtIndex = row + col;
			if(rightTop[rtIndex]) continue;
			
			//可以摆放
			queens[row] = col;
			cols[col] = true;
			leftTop[ltIndex] = true;
			rightTop[rtIndex] = true;
			place(row+1);
			
			//回溯保存现场
			cols[col] = false;
			leftTop[ltIndex] = false;
			rightTop[rtIndex] = false;
		}
	}
	//输出打印
	void show() {
		for (int row = 0; row < cols.length; row++) {
			for (int col = 0; col < cols.length; col++) {
				if (queens[row] == col) {
					System.out.print("1 ");
				} else {
					System.out.print("0 ");
				}
			}
			System.out.println();
		}
		System.out.println("------------------------------");
	}

八皇后优化–对角线
左上角-> 右下角的对角线索引：row –col + 7
右上角-> 左下角的对角线索引：row + col

八皇后优化–位运算
可以利用位运算进一步压缩八皇后的空间复杂度