八皇后问题

题目：存在8个皇后，要求任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种方法
思路：
1.第一个皇后先放在第一行第一列
2.第二个皇后放在第二行第一列，然后判断是否ok(即是否冲突)，如果不ok，继续放在第二列、第三列、一次把所有列都放完，找到一个合适
3.继续放第三个皇后，还是从第一列、第二列。。。直到第8个皇后也能放在一个不冲突的位置，算是找到一个正确解
4.当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到
5.然后回头继续第一个皇后放第二列，后面继续循环执行1，2，3，4的步骤

说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组既可解决问题 arr[8]={0,4,7,5,2,6,1,3}。0表示第一行的第一列，4表示第二行的第5列。。。。。arr下标表示第几行，即第几个皇后，arr[i]=val,val表示第i+1个皇后

先定义一个max表明共有多少个皇后，然后在定义一个数组，保存皇后存放的位置

    //定义一个max表示共有多少个皇后
    int max =8;
    //定义一个数组array,保存皇后放置位置的结果，比如arr={0,4,7,5,2,6,1,3}
    int[] array=new int[max];
    //count用来计算
    static int count=0;

    //写一个方法，可以将皇后摆放的位置输出
    private void print(){
        count++;
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    //查看当我们防止第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
    //n表示放第n个皇后
    private boolean judge(int n){
        for(int i=0;i<n;i++){
            //array[i] == array[n] 比较的是列数，即是不是在同一列
            //Math.abs(n-i) ==Math.abs(array[n]-array[i]  比较的是不是在斜线上，方法是等腰直角三角形，n-i算的是行的差值
            //array[n]-array[i] 算的是列的差值，如果两个相等就是在同一斜线上
            //判断是否是在同一行没有必要，因为n是递增的
            if(array[i] == array[n] || Math.abs(n-i) ==Math.abs(array[n]-array[i])){
                return false;
            }
        }
        return true;
    }

    //编写一个方法放置第n个皇后
    //特别注意：check是每一次递归时，进入到check中都有for(int i=0;i<max;i++).因此会有回溯
    private void check(int n){
        if(n == max){
            //n=8,说明是在放第9个皇后，n从0开始；8个皇后已然放好
            print();
            return;
        }
        //依次放入皇后并判断是否冲突
        for(int i=0;i<max;i++){
            array[n]=i;

            //判断当放置第n个皇后到i列是，是否冲突
            if(judge(n)){//不冲突
                //开始n+1个.回溯的时候开始回退
                check(n+1);
            }

            //如果冲突的话，就继续执行array[n] =i;即将第n个皇后放置在本行的后一个位置
        }
    }

    public static void main(String[] args) {
        //测试
        Queen8 queen8 = new Queen8();
        queen8.check(0);
        System.out.println("一共有："+count);
    }

整体：

public class Queen8 {
    //定义一个max表示共有多少个皇后
    int max =8;
    //定义一个数组array,保存皇后放置位置的结果，比如arr={0,4,7,5,2,6,1,3}
    int[] array=new int[max];
    static int count=0;
    
    public static void main(String[] args) {
        //测试
        Queen8 queen8 = new Queen8();
        queen8.check(0);
        System.out.println("一共有："+count);
    }

    //编写一个方法放置第n个皇后
    //特别注意：check是每一次递归时，进入到check中都有for(int i=0;i<max;i++).因此会有回溯
    private void check(int n){
        if(n == max){
            //n=8,说明是在放第9个皇后，n从0开始；8个皇后已然放好
            print();
            return;
        }
        //依次放入皇后并判断是否冲突
        for(int i=0;i<max;i++){
            array[n]=i;
            //判断当放置第n个皇后到i列是，是否冲突
            if(judge(n)){//不冲突
                //开始n+1个.回溯的时候开始回退
                check(n+1);
            }
            //如果冲突的话，就继续执行array[n] =i;即将第n个皇后放置在本行的后一个位置
        }
    }
    
    //查看当我们防止第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
    //n表示放第n个皇后
    private boolean judge(int n){
        for(int i=0;i<n;i++){
            //array[i] == array[n] 比较的是列数，即是不是在同一列
            //Math.abs(n-i) ==Math.abs(array[n]-array[i]  比较的是不是在斜线上，方法是等腰直角三角形，n-i算的是行的差值
            //array[n]-array[i] 算的是列的差值，如果两个相等就是在同一斜线上
            //判断是否是在同一行没有必要，因为n是递增的
            if(array[i] == array[n] || Math.abs(n-i) ==Math.abs(array[n]-array[i])){
                return false;
            }
        }
        return true;
    }

    //写一个方法，可以将皇后摆放的位置输出
    private void print(){
        count++;
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}