1. 什么是八皇后问题？
◼ 八皇后问题是一个古老而著名的问题
在8x8格的国际象棋上摆放八个皇后，使其不能互相攻击：任意两个皇后都不能处于同一行、同一列、同一斜线上
请问有多少种摆法？
LeetCode的相关题
◼ leetcode_51_N皇后：https://leetcode-cn.com/problems/n-queens/
◼ leetcode_52_N皇后 II： https://leetcode-cn.com/problems/n-queens-ii/
八皇后问题的解决思路
◼ 思路一：暴力出奇迹
从 64 个格子中选出任意 8 个格子摆放皇后，检查每一种摆法的可行性
一共 C 64
8
种摆法（大概是 4.4 ∗ 10 9 种摆法）
◼ 思路二：根据题意减小暴力程度
很显然，每一行只能放一个皇后，所以共有 8 8 种摆法（16777216 种），检查每一种摆法的可行性
◼ 思路三：回溯法
回溯 + 剪枝
八皇后实现 – 合法性检查
八皇后实现 – 从某一行开始摆放皇后
八皇后实现 – 摆放所有皇后
回溯法的具体实现代码
在这里插入代码片`public class Queens {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Queens().placeQueens(4);
}
/**
* 数组索引是行号，数组元素是列号
*/
int[] cols; //存储每一行的皇后的位置（即列号）
/**
* 一共有多少种摆法
*/
int ways;
void placeQueens(int n) {
if (n < 1) return;
cols = new int[n];
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++) {
if (isValid(row, col)) { //剪枝
// 如果当前位置合法，则在第row行第col列摆放皇后
cols[row] = col;
place(row + 1); //从下一行开始摆放
//上面那一句如果执行完，就回溯。
}
}
}
/**
* 判断第row行第col列是否可以摆放皇后
*/
boolean isValid(int row, int col) { //col表示列数
for (int i = 0; i < row; i++) { //从第0行开始，到当前行的前一行，
// 第col列已经有皇后
if (cols[i] == col) { //如果第i行存储的皇后列数与所给列数一致，则表示该位置不可以摆放
System.out.println("[" + row + "][" + col + "]=false"); //打印出剪枝操作的具体流程
return false;
}
// 第i行的皇后跟第row行第col列格子处在同一斜线上，即斜率为1
if (row - i == Math.abs(col - cols[i])) { //cols[i]表示第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("------------------------------");
}
}`
----------------------------------------------------------------------------------------
求解八皇后问题的第一种优化方法
对合法化函数进行优化，初始的检查合法化时间复杂度太高，对成员变量进行优化。使其检查合法性的操作变为O(1)级别的时间复杂度。
具体实现代码
public class Queens2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Queens2().placeQueens(4);
}
/**
* 数组索引是行号，数组元素是列号
*/
int[] queens;
/**
* 标记着某一列是否有皇后 存储着true表示这一列有皇后
*/
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];
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++) { //col是列数
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);
//如果上一条语句执行完，走到这里就会进行回溯，则要重置boolean值
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("------------------------------");
}
}
第二种优化方法——利用位运算对第一种优化方法进行进一步优化
public class Queens3 {
public static void main(String[] args) {
// 01111101 n
//&11111011 == ~00000100
// 01111001
// 1 << 2 == 00000100
//&00100000 v
// int n = 125;
// for (int i = 0; i < 8; i++) {
// int result = n & (1 << i);
// System.out.println(i + "_" + (result != 0));
// }
// int col = 7;
// int result = n & (1 << col);
// System.out.println(result != 0);
// System.out.println(Integer.toBinaryString(n));
// TODO Auto-generated method stub
new Queens3().place8Queens();
}
/**
* 数组索引是行号，数组元素是列号
*/
int[] queens;
/**
* 标记着某一列是否有皇后
*/
byte cols; //8位的每一位记录着这一列是否有皇后，从右到左
/**
* 标记着某一斜线上是否有皇后（左上角 -> 右下角）
*/
short leftTop;
/**
* 标记着某一斜线上是否有皇后（右上角 -> 左下角）
*/
short rightTop;
/**
* 一共有多少种摆法
*/
int ways;
void place8Queens() {
queens = new int[8];
place(0);
System.out.println("8皇后一共有" + ways + "种摆法");
}
/**
* 从第row行开始摆放皇后
* @param row
*/
void place(int row) {
if (row == 8) {
ways++;
show();
return;
}
for (int col = 0; col < 8; col++) {
int cv = 1 << col; //cv是1左移col位后的结果
if ((cols & cv) != 0) continue; //与cv按位与，结果不等于0则说明这一col列有皇后
int lv = 1 << (row - col + 7);
if ((leftTop & lv) != 0) continue;
int rv = 1 << (row + col);
if ((rightTop & rv) != 0) continue;
queens[row] = col; //存储在皇后数组中
cols |= cv; //与cv按位或，则可将这一位改为1（即第col列）
leftTop |= lv;
rightTop |= rv;
place(row + 1);
//执行到这里说明要回溯，则要将第col列重置为0
cols &= ~cv;
leftTop &= ~lv;
rightTop &= ~rv;
}
}
void show() {
for (int row = 0; row < 8; row++) {
for (int col = 0; col < 8; col++) {
if (queens[row] == col) {
System.out.print("1 ");
} else {
System.out.print("0 ");
}
}
System.out.println();
}
System.out.println("------------------------------");
}
}
