回溯算法--八皇后问题

八皇后问题

在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。问有多少种摆法。

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

代码实现

package com.vleus.algorithm.backtrack;

import java.util.*;

/**
 * @author vleus
 * @date 2021年06月26日 10:29
 */
public class EightQueues {

    //方法一：暴力穷举
    public static List<int[]> eightQueens1() {

        //定义保存结果的List
        List<int[]> result = new ArrayList<>();

        //用一个int[8]数组保存一组解
        int[] solution = new int[8];

        //遍历八皇后每种可以摆放的场景，判断是否符合题目限制
        for (solution[0] = 0; solution[0] < 8; solution[0]++) {
            for (solution[1] = 0; solution[1] < 8; solution[1]++) {
                for (solution[2] = 0; solution[2] < 8; solution[2]++) {
                    for (solution[3] = 0; solution[3] < 8; solution[3]++) {
                        for (solution[4] = 0; solution[4] < 8; solution[4]++) {
                            for (solution[5] = 0; solution[5] < 8; solution[5]++) {
                                for (solution[6] = 0; solution[6] < 8; solution[6]++) {
                                    for (solution[7] = 0; solution[7] < 8; solution[7]++) {
                                        if (check(solution)) {
                                            result.add(Arrays.copyOf(solution, 8));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }


        return result;
    }


    //定义一个判定当前摆放方式是否有效的方法
    private static boolean check(int[] solution) {

        //数组A中的任意两个皇后进行比较
        for (int i = 0; i < solution.length; i++) {
            for (int j = i+1; j < solution.length; j++) {
                //判断不能在同一列，不能行列索引差不能相等
                if (solution[i] == solution[j] || Math.abs(solution[i] - solution[j]) == j - i) {
                    return false;
                }
            }
        }

        return true;
    }

    //方法二：回溯法解决

    Set<Integer> cols = new HashSet<>();
    Set<Integer> dialogs1 = new HashSet<>();
    Set<Integer> dialogs2 = new HashSet<>();

    public  List<int[]> eightQueens() {

        //定义保存结果的List
        List<int[]> result = new ArrayList<>();

        //用一个int[8]数组保存一组解
        int[] solution = new int[8];

        //对solution做初始的填充,表示皇后还没有填充
        Arrays.fill(solution,-1);

        //定义回溯方法，递归调用
        backtrack(result,solution,0);

        return result;
    }

    //实现回溯方法
    private  void backtrack(List<int[]> result, int[] solution, int row) {

        //首先处理递归调用结束时候的场景
        if (row >= 8) {
            //已经直接得到了所有行的填充结果，构建一组解
            result.add(Arrays.copyOf(solution,8));
        }else{
            for (int column = 0; column < 8; column++) {
                //1.如果已经和之前的皇后冲突，寻找下一位置
                //1.1 判断同一列
                if (cols.contains(column)) {
                    continue;
                }
                int diag1 = row - column;
                int diag2 = row + column;
                if (dialogs1.contains(diag1)) {
                    continue;
                }

                if (dialogs2.contains(diag2)) {
                    continue;
                }

                //如果不冲突,当前位置就放置皇后
                solution[row] = column;
                cols.add(column);
                dialogs1.add(diag1);
                dialogs2.add(diag2);

                //递归调用，深度搜索下一行
                backtrack(result,solution,row + 1);

                //回溯，将状态回滚，继续遍历当前行皇后可能的位置
                solution[row] = -1;
                cols.remove(column);
                dialogs1.remove(diag1);
                dialogs2.remove(diag2);
            }
        }
    }

    public static void main(String[] args) {


        List<int[]> result = new EightQueues().eightQueens();

        System.out.println(result.size());

        result.forEach(item -> System.out.println(Arrays.toString(item)));
    }

}