递归回溯解决八皇后问题

文章目录

前言
八皇后问题
- 问题解析
- 代码实现
- 完整代码

前言

八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。现代教学中，把八皇后问题当成一个经典递归算法例题。

八皇后问题

问题解析

首先八个皇后之间需要满足：

不在同一列上
不在同一行上
不在同一斜线上
不在同一反斜线上

首先可以逐行进行遍历，每一行遍历出一个符合条件的位置，然后就开始遍历下一行，寻找下一个符合条件的位置，如果找的到则继续遍历下一行，否则就回溯到上一行的位置，对其他位置进行遍历重新寻找符合条件的位置。当顺利地遍历到最后一行仍然找得到符合条件的位置时，此时就完成了一种可行的八皇后摆放方案。然后继续遍历该行其他位置是否有符合条件的，没有就返回到上一行继续寻找，以此反复进行遍历就可以得出所有的摆放方案。

代码实现

初始化需要用到的变量

/*** 八个皇后*/
int max = 8;/*** 用一个一维数组来模拟整个棋盘<数组的索引表示第几行,而索引所对应的数则表示皇后放在在该行的第几列上>*/
int[] array = new int[max];/*** 用于记录有多少种摆放方案 */
int count = 0;

打印出八皇后的摆放位置

/*** 输出八皇后的位置*/
public void print()
{//满足条件 count++;for (int i = 0; i < array.length; i++) {System.out.print(array[i]+"\t");}System.out.println();
}

判断八皇后之间是否产生冲突

/*** 判断第n个皇后是否与之前的皇后发生冲突* @param n 第n个皇后* @return*/
public boolean judge(int n)
{//遍历第n个皇后之前的所有皇后for (int i = 0; i < n; i++) {//1.array[i] == array[n]   --->   第n个皇后和前面的皇后是否在同一列//2.Math.abs(i-n) == Math.abs(array[i] - array[n])   --->   第n个皇后和前面的皇后是否在同一斜线if (array[i] == array[n] || Math.abs(i-n) == Math.abs(array[i] - array[n])){return false;}}return true;
}

利用递归摆放皇后

/*** 利用递归摆放皇后* @param n 表示第n个皇后* @return*/
public void check(int n)
{//如果符合该条件说明已经完成了一种可行的摆法if (n == max){//打印摆放信息print();//回溯到上一行重新寻找可行的摆放位置return;}//通过循环从第一行开始逐列摆放皇后//通过递归来遍历行数for (int i = 0; i < max; i++){array[n] = i;//判断当前放置的皇后与其他位置上的皇后是否产生冲突if (judge(n)){check(n+1);}//如果冲突继续执行array[n]=i 重新寻找该行上可行的摆放位置}
}

完整代码

/*** @Author: 又蠢又笨的懒羊羊程序猿* @CreateTime: 2021年08月12日 20:59:14*/
public class TheEightQueensOfDeath
{public static void main(String[] args) {TheEightQueensOfDeath theEightQueensOfDeath = new TheEightQueensOfDeath();theEightQueensOfDeath.check(0);System.out.println("Result:"+theEightQueensOfDeath.count);}int max = 8;int[] array = new int[max];int count;/*** 利用递归摆放皇后* @param n 表示第n个皇后* @return*/public void check(int n){//如果符合该条件说明已经完成了一种可行的摆法if (n == max){//打印摆放信息print();//回溯到上一行重新寻找可行的摆放位置return;}//通过循环从第一行开始逐列摆放皇后//通过递归来遍历行数for (int i = 0; i < max; i++){array[n] = i;//判断当前放置的皇后与其他位置上的皇后是否产生冲突if (judge(n)){check(n+1);}//如果冲突继续执行array[n]=i 重新寻找该行上可行的摆放位置}}/*** 检测判断该皇后摆放位置是否与前面的皇后产生冲突* @param n 表示第n个皇后* @return*/public boolean judge(int n){for (int i = 0; i < n; i++) {//1.array[i] == array[n]   --->   第n个皇后和前面的皇后是否在同一列//2.Math.abs(i-n) == Math.abs(array[i] - array[n])   --->   第n个皇后和前面的皇后是否在同一斜线if (array[i] == array[n] || Math.abs(i-n) == Math.abs(array[i] - array[n])){return false;}}return true;}/*** 输出八皇后的位置*/public void print(){count++;for (int i = 0; i < array.length; i++) {System.out.print(array[i]+"\t");}System.out.println();}
}

测试结果

Result:92---->共有92种摆放方案
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

以上。

如有不足或者错误欢迎评论指正。

递归回溯解决八皇后问题相关推荐

递归/回溯：八皇后问题N-Queens
N皇后问题是计算机科学中最为经典的问题之一,该问题可追溯到1848年,由国际西洋棋棋手马克斯·贝瑟尔于提出了8皇后问题. 将N个皇后放摆放在N*N的棋盘中,互相不可攻击,有多少种摆放方式,每种摆放 ...
数据结构:回溯--解决八皇后问题
public class Queue8 {int max = 8;int count = 1;// 定义数组,保存皇后放置位置的结果,比如arr = {0,4,7,5,2,6,1,3}int[] ar ...
回溯法在解决八皇后问题中的应用
回溯法:有这样一类题目,它们要求在相对问题的输入规模按照指数速度增长(或者更快)的域中,找出一个具有指定特性的元素.例如:在图顶点的所有排列中求一个哈密顿回路,在背包问题的一个实例中求其中最有价值的物 ...
回溯算法解决八皇后_4皇后问题和使用回溯算法的解决方案
回溯算法解决八皇后 4-皇后问题 (4 - Queen's problem) In 4- queens problem, we have 4 queens to be placed on a 4*4 ...
【算法】递归|迷宫回溯问题|八皇后问题
[算法]递归|迷宫回溯问题|八皇后问题迷宫回溯问题,要用动态的眼光来看待这个递归算法. package com.serein.recursion;/*** @author baichuan* @ ...
有趣的数据结构算法12——利用递归解决八皇后问题
有趣的数据结构算法12--利用递归解决八皇后问题题目复述解题思路实现代码 GITHUB下载连接本次教程主要讲述如何利用递归解决八皇后问题,它和汉诺塔一样让人很难过. 题目复述据说西洋棋手都具 ...
回溯算法(八皇后问题)
写在前面:博主是一位普普通通的19届双非软工在读生,平时最大的爱好就是听听歌,逛逛B站.博主很喜欢的一句话花开堪折直须折,莫待无花空折枝:博主的理解是头一次为人,就应该做自己想做的事,做自己不后悔的事 ...
用lua解决八皇后问题
要解决八皇后问题,首先必须认识到每一行中只能有一个皇后.因此,可以用一个由8个数字组成的简单数组来表示可能的解决方案.例如,数组{3,7,2,1,8,6,5,4}表示皇后在棋盘中的位置分别是( ...
分治回溯算法----八皇后问题
八皇后问题:在一个8×8的棋盘中,放入8个皇后棋子,要求同行同列同斜线不能有重复的皇后棋子,八皇后问题一共有92种解法.如图所示:即八皇后问题的一个解. //分治回溯算法解决八皇后问题 public ...