精华内容
下载资源
问答
  • 8皇后java
    2022-01-08 22:22:32

    首先把judge()写出来

    再写check()方法

    public class Queue8 {
        static int max = 8;//定义一个max共有多少皇后
        static int count=0;
        static int[] array = new int[max];//定义一个数组array保存皇后放置位置的结果,比如arr={0,4,7,5,2,6,1,3} 这种也很好理解,就是皇后在第一行的第一个位置,在第二行的第5个位置,第三行的第八个位置......
        public static void main(String[] args) {
            Queue8 queue8=new Queue8();
            queue8.check(0);
            System.out.printf("一共有%d中解法",count);
        }
        //编写一个方法,放置第n+1个皇后,这里的n从0开始
        private void check(int n){
            if(n==max){//n=8,说明8个皇后已经放好,n从0开始
                print();
                return;
            }
            //一次放入皇后,并判断是否冲突
            for(int i=0;i<max;i++){
                array[n]=i;//先把当前这个皇后,放到该行的第一列
                if(judge(n)){//不冲突
                    check(n+1);//接着放n+1个皇后,即开始递归
                }
                //如果冲突,就继续执行array[n]=i;即将第n个皇后放置在本行后一个位置 就是往前一列
            }
        }
        /**
         * 查看当我们放置第n个皇后,就去检测皇后是否和前面摆放的皇后冲突
         * @param  n  n+1表示第n个皇后
         * @return
         */
        public static boolean judge(int n){
            for (int i = 0; i < n; i++) {
                //说明:
                //1.array[i]=array[n] 表示判断第n个皇后是否和前面的n-1个皇后在同一列(这个要理解一下的)
                //2.Math.abs(n-i)==Math.abs(array[n]-array[i])表示判断第n个皇后是否和第i个皇后在同一斜线上,这个也很好理解,因为在同一斜线上两个点行坐标减行坐标的值等于列坐标减列坐标的值
                //3.判断在同一行,没有必要,因为n在递增
                if(array[i]==array[n] || Math.abs(n-i)==Math.abs(array[n]-array[i])){
                    return false;
                }
            }//当第n个皇后与之前皇后都不冲突的时候,才返回true。
            return true;
        }
        //写一个方法 可以将皇后摆放的位置输出
        private void print(){
            count++;
            for(int i=0;i<array.length;i++){
                System.out.println(array[i]+" ");
            }
            System.out.println();
        }
    }
    

    这样就完成啦

     

    更多相关内容
  • 8皇后问题:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。递归,JAVA语言
  • java皇后

    2018-01-18 22:01:37
    java写的八皇后问题,可以自动随机生成解,不同于网上大部分遍历所有的解的做法,这个是利用回溯法随机找到解。
  • 8皇后算法JAVA实现

    2012-02-03 15:16:37
    8皇后问题JAVA算法 用递归实现,程序种有两种判定皇后可放的方法 一种采用辅助数组,一种采用斜率判断 代码比较简洁,对递归的理解和掌握有帮助 测试结果: 1 :1 5 8 6 3 7 2 4 2 :1 6 8 3 7 4 2 5 3 :1 7 4 6 8 2 ...
  • 8皇后 java程序

    2008-10-17 21:52:31
    8皇后 java程序 比较短小的一个递归程序
  • Java解决八皇后问题

    2022-04-26 10:51:39
    Java解决八皇后

    Java解决八皇后问题

    八皇后问题(英文:Eight queens),是由国际象棋棋手马克斯·贝瑟尔于1848年提出的问题,是回溯算法的典型案例。

    问题表述为:在8×8格的国际象棋上摆放8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。如果经过±90度、±180度旋转,和对角线对称变换的摆法看成一类,共有42类。计算机发明后,有多种计算机语言可以编程解决此问题。
    1

    8皇后之间需满足:

    1.不在同一行上

    2.不在同一列上

    3.不在同一斜线上

    回溯算法思路

    八皇后问题如果用穷举法需要尝试88=16,777,216种情况。每一列放一个皇后,可以放在第 1 行,第 2 行,……,直到第8行。穷举的时候从所有皇后都放在第1行的方案开始,检验皇后之间是否会相互攻击。如果会,把列H的皇后挪一格,验证下一个方案。移到底了就“进位”到列G的皇后挪一格,列H的皇后重新试过全部的8行。这种方法是非常低效率的,因为它并不是哪里有冲突就调整哪里,而是盲目地按既定顺序枚举所有的可能方案。

    回溯算法优于穷举法。将列A的皇后放在第一行以后,列B的皇后放在第一行已经发生冲突。这时候不必继续放列C的皇后,而是调整列B的皇后到第二行,继续冲突放第三行,不冲突了才开始进入列C。如此可依次放下列A至E的皇后,如图2所示。将每个皇后往右边横向、斜向攻击的点位用叉标记,发现列F的皇后无处安身。这时回溯到列E的皇后,将其位置由第4行调整为第8行,进入列F,发现皇后依然无处安身,再次回溯列E。此时列E已经枚举完所有情况,回溯至列D,将其由第2行移至第7行,再进入列E继续。按此算法流程最终找到如图3所示的解,成功在棋盘里放下了8个“和平共处”的皇后。继续找完全部的解共92个。

    回溯算法求解八皇后问题的原则是:有冲突解决冲突,没有冲突往前走,无路可走往回退,走到最后是答案。为了加快有无冲突的判断速度,可以给每行和两个方向的每条对角线是否有皇后占据建立标志数组。放下一个新皇后做标志,回溯时挪动一个旧皇后清除标志。

    代码如下:

     public static class TestQueen {
    
            // 皇后/棋盘的个数
            private static final int QUEEN_NUM = 8;
    
            // 首先定义一个8 * 8 的棋盘
            private static final int[][] Checkerboard = new int[QUEEN_NUM][QUEEN_NUM];
    
            // 定义一共有多少种放置皇后的算法
            private static int COUNT = 0;
    
            /**
             * 打印棋盘
             */
            public static final void show() {
                System.out.println("第" + (++COUNT) + "次摆法");
                for (int i = 0; i < QUEEN_NUM; i++) {
                    for (int j = 0; j < QUEEN_NUM; j++) {
                        System.out.print(Checkerboard[i][j] + " ");
                    }
                    System.out.println("");
                }
            }
    
    
            public static final boolean check(int row, int col) {
    
                // 判断当前位置的上面是否有皇后
                for (int i = row - 1; i >= 0; i--) {
                    if (Checkerboard[i][col] == 1)
                        return false;
                }
    
                // 判断左上是否有皇后
                for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
                    if (Checkerboard[i][j] == 1)
                        return false;
                }
    
                // 判断右上是否有皇后
                for (int i = row - 1, j = col + 1; i >= 0 && j < QUEEN_NUM; i--, j++) {
                    if (Checkerboard[i][j] == 1)
                        return false;
                }
    
                return true;
            }
    
            /**
             * 从第n行放置皇后
             *
             * @param row
             */
            public static final void play(int row) {
                // 遍历当前行的所有单元格 以列为单元
                for (int i = 0; i < QUEEN_NUM; i++) {
                    // 是否能够放置皇后
                    if (check(row, i)) {
                        Checkerboard[row][i] = 1;
    
                        if (row == QUEEN_NUM - 1) {
                            // 最后行 放置完毕 打印皇后
                            show();
                        } else {
                            // 放置下一行
                            play(row + 1);
                        }
    
                        //回退到当前步骤,把皇后设置为0
                        Checkerboard[row][i] = 0;
                    }
    
                }
            }
    
            public static void main(String[] args) {
                play(0);
            }
        }
    

    运行结果

    2

    展开全文
  • 该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即:任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法(92)。 注: 理论上应该创建一个二...

    什么是八皇后问题

    八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即:任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法(92)。
    在这里插入图片描述

    思路分析

    1. 第一个皇后先放第一行第一列
    2. 第二个皇后放在第二行第一列、然后判断是否OK,如果不OK,继续放在第二列、第三列、依次把所有列都放完,找到一个合适
    3. 继续第三个皇后,还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置,算是找到了一个正确解
    4. 当得到一个正确解时,在栈回退到上一个栈时,就会开始回溯,即将第一个皇后,放到第一列的所有正确解,全部得到.
    5. 然后回头继续第一个皇后放第二列,后面继续循环执行1,2,3,4的步骤

    在这里插入图片描述

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

    代码实现

    package stack.queue;
    
    
    import java.util.concurrent.CountDownLatch;
    
    public class Queen8Test {
    
    
        //定义一个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) {
    
            Queen8Test queen8 = new Queen8Test();
            queen8.check(0);
            System.out.println("解法:" + count);
    
            //随机拿出一组,复原 比如0 就是 第一行,第一列,4就是第二行的第五列
            int[] arr =  new int[]{0 ,4 ,7 ,5 ,2 ,6 ,1 ,3 };
            int[][] queenArr = new int[8][8];
            //初始化棋盘
            for (int[] data:queenArr) {
                for (int item : data){
                    System.out.printf("%4d",item);
                }
                System.out.println();
            }
            for (int i = 0; i < arr.length; i++) {
                queenArr[i][arr[i]] = 1;
            }
    
            System.out.println("===============================");
            //放置皇后的位置设置为1
            for (int[] data:queenArr) {
                for (int item : data){
                    System.out.printf("%4d",item);
                }
                System.out.println();
            }
        }
    
        /**
         * 查看当我们放置第n个皇后,检测该皇后是否和前面已经摆放的冲突
         * @param n 第几个皇后
         * @return
         */
        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 = 1 ==>第二个皇后,放在第二列  n=1 array[1]=1 。
                // n-i 理解为x坐标,也就是数组索引下标为x,数组的值是y,当这两个值相等,斜率就是1,所以在一个斜线上
                //Math.abs(1 - 0) = 1     Math.abs(1 - 0) = 1
                if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])){
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 放置皇后
         * check没依次递归的时候,进入到check方法都有一套for循环,因此会有回溯。相当于8个栈,每个栈有一个check方法
         * @param n
         */
    
        public void check(int n){
            if (n ==  max){ //8个皇后已经放置完成
                print();
                return;
            }
            //依次放入皇后,并判断
            for (int i = 0; i < max; i++) {
                //先把当前皇后 放到该行的第1列
                array[n] = i;
                //判断放放置第n个皇后后到i列时候,是否冲突
                if (judge(n)){
                    //接着放n+1个皇后
                    check(n + 1);
                }
                //若冲突,就继续执行array[n] == i ,即将第n个皇后,放置在本行的后移的一个位置。
            }
        }
        //将皇后位置输出
        private void print(){
            count++;
            for (int i = 0; i < array.length; i++) {
                System.out.print( array[i] + " ");
            }
            System.out.println();
        }
    }
    
    
    

    部分输出结果
    在这里插入图片描述

    展开全文
  • 皇后Java实现)

    千次阅读 2021-03-17 11:28:26
    1.问题介绍 八皇后问题是一个古老而著名的问题,是回溯算法和递归调用的典型案例。...继续放置第三个皇后,还是第一列、第二列…直到第8皇后也能放在一个不能相互攻击的位置,就找到了一个正确解。 当得到一个正

    1.问题介绍

    八皇后问题是一个古老而著名的问题,是回溯算法和递归调用的典型案例。八皇后难题是要将八个皇后(Queen)放在棋盘上,任何两个皇后都不能互相攻击(即没有任意两个皇后是在同一行、同一列或者同一条对角线上),问一共有多少种摆法。

    2.思路分析

    1. 第一个皇后先放在第一行第一列
    2. 第二个皇后放在第二行第一列,然后判断能否在该位置放皇后,如果不可以,则继续放下一列,直至找到一个合适的位置
    3. 继续放置第三个皇后,还是第一列、第二列…直到第8个皇后也能放在一个不能相互攻击的位置,就找到了一个正确解。
    4. 当得到一个正确解时,在栈回退到上一个栈时,就会开始回溯。即将第一个皇后放在第一列的所有解逐个得到。
    5. 完成以上步骤之后,将第一个皇后放在第二列,后面循环执行1, 2, 3, 4 步骤。

    在这里插入图片描述

    3.代码实现

    package eightqueen;
    
    public class eightqueen {
        public static int MAXQUEEN = 8;   //皇后个数,也是棋盘行列数
        public static int[][] Board = new int[MAXQUEEN][MAXQUEEN];    //初始化棋盘
        private static int count;
    
        public static void startTest(Todo Todo, int row){
            //第0列开始
            for (int col = 0; col < MAXQUEEN; col++) {
                //检查位置是否可以放棋子
                if (Todo.checkBoard(MAXQUEEN, row, col, Board) == 1){
                    if (row == MAXQUEEN - 1){
                        count++;
                    }
                    //递归,向下一行前进
                    if (row < MAXQUEEN - 1){
                        startTest(Todo, ++row);
                        //回退上一个栈
                        --row;
                    }
                }
                //重新赋值为0,进行下一次判断
                Board[row][col] = 0;
            }
        }
    
        public static void main(String[] args) {
            int row = 0;
            Todo Todo1 = new Todo();
            startTest(Todo1, row);
    
            System.out.println("摆放一共有" + count + "种");
        }
    }
    
    class Todo {
        //定义横竖斜方向上是否有棋子
        public static boolean flag = true;
        //检查棋盘
        public int checkBoard(int MAXQUEEN, int row, int col, int[][] Board){
            //行方向上
            for (int i = 0; i < MAXQUEEN; i++) {
                if (Board[row][i] == 1){
                    return 0;
                }
            }
            //列方向上
            for (int i = 0; i < MAXQUEEN; i++) {
                if (Board[i][col] == 1){
                    return 0;
                }
            }
            //右下方向上
            for (int i = row, j = col; i < MAXQUEEN && j < MAXQUEEN; i++, j++) {
                if (Board[i][j] == 1){
                    return 0;
                }
            }
            //左上方向上
            for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
                if (Board[i][j] == 1){
                    return 0;
                }
            }
            //左下方向上
            for (int i = row, j = col; i < MAXQUEEN && j >= 0; i++, j--) {
                if (Board[i][j] == 1){
                    return 0;
                }
            }
            //右上方向上
            for (int i = row, j = col; i >= 0 && j < MAXQUEEN; i--, j++) {
                if (Board[i][j] == 1){
                    return 0;
                }
            }
            if (flag) {
                //此点符合要求,可以下
                Board[row][col] = 1;
                //如果已经到最后一行,则打印棋盘
    //            if (row == MAXQUEEN - 1){
    //                printBoard(MAXQUEEN, Board);
    //            }
                //可以放
                return 1;
            }
            return 0;
        }
        //打印棋盘
        public static void printBoard(int MAXQUEEN, int[][] Board){
            for (int i = 0; i < MAXQUEEN; i++) {
                for (int j = 0; j < MAXQUEEN; j++){
                    System.out.print(Board[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("================");
        }
    }
    

    4.最终结果

    在这里插入图片描述

    展开全文
  • 皇后问题java实现

    2021-08-15 13:53:45
    8×8格的国际象棋上摆放8皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。 后面陆续有不同的学者提出自己的见解。大数学家高斯认为一共有76种摆法,1854年在柏林...
  • 皇后java源码

    2017-08-30 19:05:23
    该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。 高斯认为有76种方案。1854年在...
  • 8皇后问题java版的图形界面演示,swing做的可运行jar文件。看了回朔算法,简洁的让人震撼,很有感触,就做了个图形演示界面。
  • 皇后Java的图形界面实现,采用回溯法,演示可控。
  • 皇后问题Java

    2022-01-26 23:20:02
    思路分析: 把第一个皇后放到第一行第一列 ...(4)直至第8皇后也能放到合适位置,此时第一个符合要求摆法便找到。 (5)当得到一个正确解时,在栈回退到上一个栈时,就会开始回溯。把第一个皇后在第一行第一列...
  • 皇后JAVA解法

    2015-02-03 10:05:21
    皇后的递归解法,欢迎改进讨论。 下载后把java 类放到想要的package 下即可运行
  • 4-皇后拼图4皇后问题的可视化 - 用JAVA实现四皇后问题包括将四个皇后放在一个 4 x 4 的棋盘上,以便没有两个皇后可以互相捕获。 也就是说,不允许将两个皇后放在同一行、同一列或同一对角线上。
  • 将 n 个皇后摆放在一个 n x n 的棋盘上,使得每一个皇后都无法攻击到其他皇后,N皇后问题是一个典型的约束求解问题,利用递归机制,可以很快的得到结果,本文将详细介绍,需要了解的朋友可以参考下
  • java 8皇后问题

    2015-08-29 10:58:01
    java解决8皇后问题,swing做的图形演示界面。看了回朔算法,简洁的让人震撼,很有感触,就做了个演示界面。
  • 8x8的棋盘上, 放 8皇后 任意两个皇后 不能共线,就是不能同行,同列,同斜线。 高斯76中。 八皇后问题,是一个古老而著名的问题,是回湖算法的典型案例。该问题是国际西洋棋棋手马克斯•贝瑟尔于 1848年提出...
  • JAVA实现的八皇后问题

    2013-07-24 17:45:54
    JAVA实现的八皇后问题。学习JAVA时练手写的程序,分享下。我真是各种喜欢写八皇后算法
  • Java皇后游戏.rar

    2019-08-22 11:34:35
    经典的八皇后游戏是要将八个皇后放在棋盘上,任何两个皇后都不能互相攻击(即没有两个皇后是在同一行、同一列或者同一对角上)。
  • java 编程8皇后问题

    2013-11-30 15:48:29
    8皇后问题复杂性描述,输入一定方格个数,即可输出最好的排列方式。
  • Java实现八皇后问题

    千次阅读 多人点赞 2022-03-12 21:08:47
    快速理解八皇后问题!
  • 主要介绍了java实现八皇后问题示例,八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出
  • 主要介绍了Java基于循环递归回溯实现八皇后问题算法,结合具体实例形式分析了java的遍历、递归、回溯等算法实现八皇后问题的具体步骤与相关操作技巧,需要的朋友可以参考下
  • 主要介绍了如何基于java语言实现八皇后问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,695
精华内容 3,878
关键字:

8皇后java