问题

八皇后问题是一个古老而著名的问题，是试探法的典型例题。该问题由19世纪数学家高斯1850年手工解决。原题为在8×8格的国际象棋上摆着8个皇后，使其不能相互攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法？

思路

就是用试探法解决此问题，试探法也叫回溯算法。思路还是很直接的，就是一个一个的尝试。 你要创建一个数组用来存储每行中合适的列的标号，而且这个数组需要被反复使用， 数组的下标天然地能够表示一行，又因为一行中不可能出现2个以上的皇后，所以就可以用一维数组的每个元素 来表示一行，每个元素的值就是列的标号。 8皇后问题就是要求出现过皇后的横纵斜向都不能再出现皇后了。 如何判断当前行的列值是否满足这个要求呢？其实很简单，你先画一个二维表，横纵向都标上标号，行姑且设为x， ，列姑且设为y，并设两个点(x0,y0)和(x1,y1)，那你就会发现。 1、左下右上的斜线满足x1+y1=x0+y0。 2、左上右下的斜线满足x1-x0=y1-y0。 3、纵向相等满足y0=y1。 所以每当遇到新行的时候，你就可以通过上面这3个步骤来判断该行上的某列合不合适，再以此类推，这样就试探出合适的列 。因为针对前一行的可行的解，后一行需要试探8次，所以总共需要试探8⁸次，再说明白一点这有点类似于排列组合问题，由此可见它的时间复杂度相当高。解这个问题有点像解密码锁，那试探法有点像暴力破解。这个一维数组可以看成是一个栈，针对于当前栈顶指针所对应的位置的值，它可以连续尝试8次，当达到上线以后它就应该出栈了。此时栈顶指针被减一，那么此时的栈顶到栈底之间的各值肯定都是合适的，于是栈顶指针就应该在其值加1到8之间再去尝试，针对于每一个值都先入栈，判断其合不合适，合适就留这，不合适就出栈重试。如果合适就把栈顶指针+1，并且针对于当前栈顶指针的值从1到8进行尝试，直到遇到一个合适的。但是这样操作栈太绕了，想起来不容易。所以换一种思路，那就开密码锁吧。假设有一个轮盘组，用一个指针指向某轮盘，就是当前正在调整的轮盘。该指针前面的轮盘都已经是合适的，该指针后面的轮盘有待尝试，该指针是要调整的。那什么时候需要停呢？就是左边第一个轮子上越界的时候，因为这是8皇后问题，所以上越界就是大于7。什么时候该往右？那就是当前轮盘已经调整完了，而下一个轮盘还没确定的时候。这里面有一个特殊的情况，那就是当前轮盘已经是最后一个盘子了，那么此时等它上越界的时候就该往左移动了。什么时候该往左呢？就是当前轮盘上越界的时候。这里面也有个特殊情况那就是当第一个轮盘上越界的时候，算法就结束了。那么再简化一下思路就是1、先调整当前的盘子。2、如果经过调整以后当前盘子上越界了，则指针指向前一个盘子。3、如果当前盘子不是最后一个，把盘子指向下一个。接下来看代码就行了。这个算法不仅仅局限于8皇后，只要是大于1的自然数都行。

使用

package com.company;

public class Main {

    public static void main(String[] args) {
    // write your code here
        Solution.eightQueens(8);
    }
}

输出

0 4 7 5 2 6 1 3 
0 5 7 2 6 3 1 4 
0 6 3 5 7 1 4 2 
0 6 4 7 1 3 5 2 
1 3 5 7 2 0 6 4 
1 4 6 0 2 7 5 3 
1 4 6 3 0 7 5 2 
1 5 0 6 3 7 2 4 
1 5 7 2 0 3 6 4 
1 6 2 5 7 4 0 3 
1 6 4 7 0 3 5 2 
1 7 5 0 2 4 6 3 
2 0 6 4 7 1 3 5 
2 4 1 7 0 6 3 5 
2 4 1 7 5 3 6 0 
2 4 6 0 3 1 7 5 
2 4 7 3 0 6 1 5 
2 5 1 4 7 0 6 3 
2 5 1 6 0 3 7 4 
2 5 1 6 4 0 7 3 
2 5 3 0 7 4 6 1 
2 5 3 1 7 4 6 0 
2 5 7 0 3 6 4 1 
2 5 7 0 4 6 1 3 
2 5 7 1 3 0 6 4 
2 6 1 7 4 0 3 5 
2 6 1 7 5 3 0 4 
2 7 3 6 0 5 1 4 
3 0 4 7 1 6 2 5 
3 0 4 7 5 2 6 1 
3 1 4 7 5 0 2 6 
3 1 6 2 5 7 0 4 
3 1 6 2 5 7 4 0 
3 1 6 4 0 7 5 2 
3 1 7 4 6 0 2 5 
3 1 7 5 0 2 4 6 
3 5 0 4 1 7 2 6 
3 5 7 1 6 0 2 4 
3 5 7 2 0 6 4 1 
3 6 0 7 4 1 5 2 
3 6 2 7 1 4 0 5 
3 6 4 1 5 0 2 7 
3 6 4 2 0 5 7 1 
3 7 0 2 5 1 6 4 
3 7 0 4 6 1 5 2 
3 7 4 2 0 6 1 5 
4 0 3 5 7 1 6 2 
4 0 7 3 1 6 2 5 
4 0 7 5 2 6 1 3 
4 1 3 5 7 2 0 6 
4 1 3 6 2 7 5 0 
4 1 5 0 6 3 7 2 
4 1 7 0 3 6 2 5 
4 2 0 5 7 1 3 6 
4 2 0 6 1 7 5 3 
4 2 7 3 6 0 5 1 
4 6 0 2 7 5 3 1 
4 6 0 3 1 7 5 2 
4 6 1 3 7 0 2 5 
4 6 1 5 2 0 3 7 
4 6 1 5 2 0 7 3 
4 6 3 0 2 7 5 1 
4 7 3 0 2 5 1 6 
4 7 3 0 6 1 5 2 
5 0 4 1 7 2 6 3 
5 1 6 0 2 4 7 3 
5 1 6 0 3 7 4 2 
5 2 0 6 4 7 1 3 
5 2 0 7 3 1 6 4 
5 2 0 7 4 1 3 6 
5 2 4 6 0 3 1 7 
5 2 4 7 0 3 1 6 
5 2 6 1 3 7 0 4 
5 2 6 1 7 4 0 3 
5 2 6 3 0 7 1 4 
5 3 0 4 7 1 6 2 
5 3 1 7 4 6 0 2 
5 3 6 0 2 4 1 7 
5 3 6 0 7 1 4 2 
5 7 1 3 0 6 4 2 
6 0 2 7 5 3 1 4 
6 1 3 0 7 4 2 5 
6 1 5 2 0 3 7 4 
6 2 0 5 7 4 1 3 
6 2 7 1 4 0 5 3 
6 3 1 4 7 0 2 5 
6 3 1 7 5 0 2 4 
6 4 2 0 5 7 1 3 
7 1 3 0 6 4 2 5 
7 1 4 2 0 6 3 5 
7 2 0 5 1 4 6 3 
7 3 0 2 5 1 6 4 
一共有92种解法

实现

package com.company;

public class Solution {
    /**
     * N皇后问题
     * @param maxDimension
     */
    static public void eightQueens(int maxDimension) {
        if (maxDimension < 1) {
            System.out.println("输入错误");
            return;
        }
        int[] wheelGroup = new int[maxDimension];
        int currentWheel = 0;
        wheelGroup[currentWheel] = -1;
        int solutionCounter = 0;
        while (wheelGroup[0] < maxDimension) {
            //首先调整当前的轮子
            do {
                wheelGroup[currentWheel]++;
                if (wheelGroup[currentWheel] < maxDimension && Solution.isOK(wheelGroup,currentWheel,wheelGroup[currentWheel])) {
                    if (currentWheel == maxDimension - 1) {
                        solutionCounter++;
                        for (int element:wheelGroup)System.out.print(element + " ");
                        System.out.println();
                    }
                    break;
                }
            }while (wheelGroup[currentWheel] < maxDimension);
            if (wheelGroup[currentWheel] >= maxDimension) {
                if (currentWheel > 0) {
                    currentWheel--;
                }
                continue;
            }
            if (currentWheel < maxDimension - 1) {
                currentWheel++;
                wheelGroup[currentWheel] = -1;
            }
        }
        System.out.println("一共有" + solutionCounter + "种解法");
    }

    /**
     * 判断某坐标是否
     * @param columnStack
     * @param row
     * @param column
     * @return
     */
    static private boolean isOK(int[] columnStack,int row,int column) {
        for (int preRow = 0;preRow < row;preRow++) {
            if ((preRow + columnStack[preRow] == column + row) ||
                    (row - preRow == column - columnStack[preRow])  ||
                    (column == columnStack[preRow]))
                return false;
        }
        return true;
    }
}