秒懂八皇后，秒杀汉诺塔，搞定迷宫问题---风之java

最新推荐文章于 2022-05-20 16:10:56 发布
最新推荐文章于 2022-05-20 16:10:56 发布
阅读量1.5k 收藏 9
点赞数 24
分类专栏： JAVA数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56182317/article/details/119714443
版权

风生

八皇后

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

源码

public class Demo {
    static int TRUE = 1, FALSE = 0, EIGHT = 8;
    static int[] queen = new int[EIGHT];
    static int number = 0;
    static int count=0;
    //构造函数
    public Demo() {
        number = 0;
    }
    public static void print1(){
        count++;
        for(int i=0;i<EIGHT;i++){
            System.out.print(queen[i]+" ");
        }
        System.out.println();
    }
        //判断在（row，col）上的皇后是否遭受攻击
    public static boolean attack(int row) {
        for(int i=0;i<row;i++){
          if(queen[i]==queen[row]||Math.abs(i-row)==Math.abs(queen[i]-queen[row])){
                return false;
            }
        }
        return true;
    }
        //确定皇后放的位置
    public static void thePlace(int row){
        if(row==EIGHT){
            print1();
            print2();
            return;
        }
        for(int i=0;i<EIGHT;i++){
            queen[row]=i;
            if(attack(row))
                thePlace(row+1);
        }
    }
    public static void main(String[] args){
        thePlace(0);
        System.out.println(count);
    }
}

图示分析秒懂源码

static int[] queen = new int[EIGHT];
注释：源码中row代表行数，请读者想象出一个棋盘，这里定义一个一维数组queen[EIGHT];用一维数组的每一个源数的下标作为行号，下标对应的数组中的数值作为列号。所以每打印出来的一个一维数中的每一个元素及其对应的下标即为每一种情况下对应的所有落子的坐标

  public static boolean attack(int row) {
        for(int i=0;i<row;i++){
          if(queen[i]==queen[row]||Math.abs(i-row)==Math.abs(queen[i]-queen[row])){
                return false;
            }
        }
        return true;
    }

attack()方法是用来判断，其落子处所对应的列号和对角线上是否有其他皇后，如果有则不进入递归，反之则进入递归，

解析：
注意看源码中，main函数在最底下，仅调用了 thePlace（）方法，传入参数为0，即在此方法中row（行数）先为0，先判断row(行数)是否等于EIGHT(EIGHT=8)；不等于，往下进入for循环，for循环中有涉及递归，注意看下面的图示：
在这里插入图片描述
第一次棋盘为空直接落子，进入递归。
每一次进入递归都是因为找到了确定的行中的某一列可以落子的地方。找不到则在当前递归层数中进入for循环，直到找到可以落子的地方。如果循环到头，则返回上一层递归中的for循环。如此一直循环下去则可以统计出所有情况。
在这里插入图片描述

再进阶：把每一种情况的棋图都打印出来

 public static void print2(){
        String[][] arr={{" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "}};
        for(int i=0;i<EIGHT;i++){
            arr[i][queen[i]]="*";
        }
        for(int i=0;i<EIGHT;i++){
            for(int j=0;j<EIGHT;j++) {
                if(j<EIGHT-1) {
                    System.out.print(" " + arr[i][j] + " ");
                    System.out.print("|");
                }else{
                    System.out.print(" " + arr[i][j] + " ");
                }
            }
            System.out.println();

                if(i<EIGHT-1){
                    for (int k = 0; k < EIGHT; k++) {
                        if(k==7)
                        System.out.print("---");
                        else
                            System.out.print("---|");
                    }
                }
            System.out.println();
        }
    }

整体代码实现

package 八皇后问题;

public class Demo {
    static int TRUE = 1, FALSE = 0, EIGHT = 8;
    static int[] queen = new int[EIGHT];
    static int number = 0;
    static int count=0;
    //构造函数
    public Demo() {
        number = 0;
    }

    //打印一维数组结果
    public static void print1(){
        count++;
        for(int i=0;i<EIGHT;i++){
            System.out.print(queen[i]+" ");
        }
        System.out.println();
    }
    //打印棋盘式结果
    public static void print2(){
        String[][] arr={{" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "},
                {" "," "," "," "," "," "," "," "}};
        for(int i=0;i<EIGHT;i++){
            arr[i][queen[i]]="*";
        }
        for(int i=0;i<EIGHT;i++){
            for(int j=0;j<EIGHT;j++) {
                if(j<EIGHT-1) {
                    System.out.print(" " + arr[i][j] + " ");
                    System.out.print("|");
                }else{
                    System.out.print(" " + arr[i][j] + " ");
                }
            }
            System.out.println();

                if(i<EIGHT-1){
                    for (int k = 0; k < EIGHT; k++) {
                        if(k==7)
                        System.out.print("---");
                        else
                            System.out.print("---|");
                    }
                }
            System.out.println();
        }
    }
    //判断在（row，col）上的皇后是否遭受攻击
    public static boolean attack(int row) {
        for(int i=0;i<row;i++){
            if(queen[i]==queen[row]||Math.abs(i-row)==Math.abs(queen[i]-queen[row])){
                return false;
            }
        }
        return true;
    }
    //确定皇后放的位置
    public static void thePlace(int row){
        if(row==EIGHT){
            print1();
            print2();
            return;
        }
        for(int i=0;i<EIGHT;i++){
            queen[row]=i;
            if(attack(row))
                thePlace(row+1);
        }
    }
    public static void main(String[] args){
        thePlace(0);
        System.out.println(count);
    }


}

在这里插入图片描述

汉诺塔

汉诺塔：汉诺塔(Tower of Hanoi)源于印度传说中，大梵天创造世界时造了三根金钢石柱子，其中一根柱子自底向上叠着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
当圆盘为n时，一共要挪动多少次？

源码

import java.util.Scanner;

public class Demo2 {
    static int times;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入盘子数量");
        int j=sc.nextInt();
        hanoi(j,'A','B','C');
    }
    public static void move(int disk,char p1,char p3){
        System.out.println("第"+(++Demo2.times)+"次将"+disk+"从"+p1+"移动到"+p3);
    }

    public static void hanoi(int n,char p1,char p2,char p3){
        if(n==1) {
            move(n,p1, p3);
        }else{
        		//将n-1个圆盘移到B柱上
            hanoi(n-1,p1,p3,p2);
            //将最后一个圆盘移到C柱上
            move(n,p1,p3);
            //将n-1个圆盘移到C柱上
            hanoi(n-1,p2,p1,p3);
        }
    }
}

图示分析秒杀源码

以n=3进行分析。
在这里插入图片描述

迷宫问题之在源码解释

有一个迷宫地图，有一些可达的位置，也有一些不可达的位置（障碍、墙壁、边界）。从一个位置到下一个位置只能通过向上（或者向右、或者向下、或者向左）走一步来实现，从起点出发，如何找到一条到达终点的通路。并在走过的路径下留下标记。

先用链表模拟一个堆栈：

public class Node {
    int x;
    int y;
    Node next;

    public Node(){}

    public Node(int x,int y){
        this.x =x;
        this.y =y;
        next=null;
    }
}


public class NodeList {
    Node first;
    Node last;
    //压栈
    public void push(int x,int y){
        Node newNode=new Node(x,y);
        if(first==null){
            first=newNode;
            last=newNode;
        }else{
            last.next=newNode;
            last=newNode;
        }
    }
    //出栈
    public void pop(){
        if(first==null){
            System.out.println("堆栈已满，误删除选项");
            return;
        }else{
            Node delNode=first;
            while(delNode.next!=last)
                delNode=delNode.next;
            delNode.next=last.next;
            last=delNode;
        }
    }
}

操作堆栈解决问题

public class Demo {
   public  static int exitx=8;
    public static int exity=10;
public static int[][] arr = {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
               {1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
               {1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1},
               {1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1},
               {1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1},
               {1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1},
               {1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1},
               {1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1},
               {1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1},
               {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    };


    public static void main(String[] args) {
        int x = 1;
        int y = 1;
        NodeList L = new NodeList();
        System.out.println("老鼠走前");
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 12; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        while (x <=exitx&&y<=exity){
            arr[x][y]=2;
            if(arr[x-1][y]==0){
                x--;
                L.push(x,y);
            }else if(arr[x+1][y]==0){
                x++;
                L.push(x,y);
            }else if(arr[x][y-1]==0){
                y--;
                L.push(x,y);
            }else if(arr[x][y+1]==0){
                y++;
                L.push(x,y);
            }else{
                if(chkExit(x,y,exitx,exity)){
                    break;
                }
                else{
                    arr[x][y]=2;
                    L.pop();
                    x=L.last.x;
                    y=L.last.y;
                }
            }
        }
        System.out.println("老鼠走后");
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 12; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
   public static boolean chkExit(int x,int y,int exitx,int exity) {
       if (x == exitx && y == exity) {
           if(arr[x-1][y]==1||arr[x+1][y]==1||arr[x][y-1]==1||arr[x][y+1]==2){
               return true;
           }else if(arr[x-1][y]==1||arr[x+1][y]==1||arr[x][y-1]==2||arr[x][y+1]==1){
               return true;
           }else if(arr[x-1][y]==1||arr[x+1][y]==2||arr[x][y-1]==1||arr[x][y+1]==1){
               return true;
           }else if(arr[x-1][y]==2||arr[x+1][y]==1||arr[x][y-1]==1||arr[x][y+1]==1)
               return true;
           else
               return false;
       }else{
           return false;
       }
   }
}
风生u
关注
专栏目录
韩顺平 | 八皇后解法
weixin_52495418的博客
09-27 744
用一维数组解八皇后
递归算法与两个经典问题：汉诺塔问题和八皇后问题
Carl_helloworld
11-23 1591
函数在其函数体里又包含对其自身的调用，称为递归。例如阶乘函数f(n)就可以用递归表示为 int f(int n){ if(n==0){ return 1; } else{ return n*f(n-1) } } 而其非递归表示为 int g(int n){ int s=1; i
八皇后问题解法大全及编写八皇后小游戏
weixin_49561445的博客
03-01 5805
引入 八皇后问题：是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即： 任意两个皇后都不能处于同一行 、 同一列或同一斜线上，问有多少种摆法(92)。 根据排列组合：C64 取8，一共有4.426×10的9次方种方案 不难发现，每一行只能放一个皇后，所以8！=40320种方案 然后在40320种方案中，挑选符合题意的方案！ 八皇后地图 根据条件我们可知每行每列最多都只能有一个皇后，这样可以在一定
八皇后问题--回溯算法
weixin_50125130的博客
05-20 251
思路 1.八个皇后在8*8棋盘中不能互相攻击，即不能在同一行同一列和同一斜线上 2. 使用暴力破解算法，进行穷举法，每摆放一个皇后判断，是否与之前摆放在皇后产生冲突（不能互相攻击） 3. 若产生互相攻击则尝试，下一个一位置。若同行的位置的测试完不行则，进行回溯，到上一行，进行下一个位置的摆放。 4. 当摆放到第八个皇后时，表示一种解法。 思路2 1.用一个一维数组模拟8*8棋盘。数组的下标表示，行，值标时列。 数组下标与要摆放的皇后相等 2. 判断是否冲突方法。只需判断列和斜线上是否有皇后。行不需要判断，因
8皇后问题详细过程
bleedingfight的博客
08-05 2682
八皇后问题 在一个8x8的棋盘上，每行每列防止棋子“皇后”，”皇后“不能在同一行，同一列同一条斜线上。 对于这个问题通常的做法是： 1. 在一行第一个位置放置一个 2. 遍历第二行，如果找到第一个可放置的位置，则放置，遍历下一行。否则跳转到上一行遍历下一个位置。 3. 一直重复直到所有的位置都被遍历完。 为了便于说明，下面使用4皇后说明。 四皇后坐标 0001 02 03 1...
汉诺塔问题（非常简单明了的解析）
qq_29462849的博客
04-30 6603
问题介绍 汉诺塔是一个经典问题，如下图所示，考虑的是如何把A中的方块完全移动到C上，而且在移动的过程中可以借助B，但是要保证，总是小的圆块放到大的圆块上。 网上关于这类问题已经有很多解析方案了，但是对初学者来说不够简单明了，这里会用图示的方法一步一步带你了解 源代码 #include<iostream> using namespace std; void move(int n, c...
hannuota.rar_Hanoi_non-recursive_hannuota_汉诺塔_汉诺塔-递归算法_递归 非递归
09-22
汉诺塔问题是一个经典的计算机科学问题，源自一个古老的印度传说。该问题涉及到三根柱子和一堆盘子，目标是将所有盘子从第一根柱子（A柱）移动到第三根柱子（C柱），但每次只能移动一个盘子，并且任何时候大盘子都不...
汉诺塔java源码-Tower-of-Hanoi:Java河内之塔游戏
06-06
汉诺塔java源码河内塔 Java河内之塔游戏 Swing Gui、Sound 和 SQL 链接的排行榜 下载、解压、运行： 更新：代码已调整，因此 jdbc 驱动程序现在位于程序文件文件夹中。 此 jar 未上传到 github，因此如果克隆 repo，...
【零基础学Java】第八天 递归解决迷宫，汉诺塔，八皇后问题 （详解）
m0_54024106的博客
04-21 2845
🔥本文主要讲的是通过递归来实现三个经典的问题，解决迷宫，汉诺塔，八皇后问题
C语言-汉诺塔问题解决源码.zip
最新发布
11-17
汉诺塔问题是一个经典的递归问题，源自印度的古老传说，它涉及到将一系列盘子从一根柱子移动到另一根柱子，遵循特定的规则。在这个问题中，我们有三根柱子A、B和C，以及n个大小不一的盘子，最初所有盘子都在柱子A上...
java解决迷宫和八皇后问题
临时抱不到佛脚的博客
10-27 136
迷宫问题 通过递归让目标从黑点走到蓝点 package com.data.migong; public class MiGong { public static void main(String[] args) { int[][] map=new int[8][7];//根据地图创建二维数组 for (int i = 0; i <7 ; i++) { map[0][i]=1; map[7][i]=1;
【递归1】汉诺塔
吹啊~吹啊~大风吹~~
09-14 672
汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。 后来，这个传说就演变为汉诺塔游戏，玩法如下: 1.有三根杆子A,B,C。A杆上有若干碟子 2.每次移动一块...
玩转八皇后问题的正确姿势
a23452的博客
09-09 272
Hello,我是C风， 对于初学者或者编程小白来说，八皇后问题就是一个重要的坎，今天我们就详细来看看玩转八皇后的正确姿势，其中夹杂本人的一些理解，如有错误，欢迎批评指正~~ 分析：八皇后问题首先就是要明确我们不是一次性把所有皇后摆在棋盘上，而是按行来摆放皇后，皇后的摆放就是按照一个层序进行，这就形成了一个递归，因为每个皇后的摆放具有相同的思路。 在调试的过程中发现这里的结束语句不只是那个return，return只是代表当前执行函数的结束，也就是只是代表了一层函数的结束，进入主调函数，就是回溯；还有就是非r
递归—八皇后问题
qq_61630897的博客
01-23 186
八皇后问题介绍： 在一个棋盘上放置皇后，要求任意的两个皇后都不能处于同一行，同一列，和同一斜线上，问一共有多少种摆法； 解题思路： 1.第一个皇后放置在第一行第一列； 2.第二个皇后放在第二行第一列判断是否符合条件，如果不符合就放在第二列，直到找到一个正确的位置； 3.继续第三个皇后，还是第一列开始判断是否合理，依次找下去，直到八个皇后都找到了合理的位置，这就是一个正确的解， 4.当找到一个正确的解时，在栈回退到上一个栈时，就会开始回溯，既将第一个皇后，放在第一行的所有解全部找出 5.然后在将
[玩耍]八皇后问题动态演示
蟹脑板的博客
05-06 3749
学校组织的计算机技能大赛，题目解八皇后并做程序演示，顺便就贴博客上来。八皇后问题简述：8*8的棋盘，有八个皇后，每个皇后不能在同一行同一列同一斜线上，问有多少种可能的摆法。答案是92，这大家都知道。解法与优化首先肯定是遍历嘛，关键是要剪枝。1.暴力枚举8个子所有点遍历一遍，8个嵌套for，一共C864C_{64}^{8}种情况。曰曰2.回溯法由于每个皇后不能在一行，那八个皇后就在八个不同行上面嘛，对
汉诺塔java源码-code-challenges:享受编码和解决问题的乐趣
06-06
汉诺塔java源码代码挑战 有趣的编码和解决来自不同来源的问题 问题解决 力码 罗马到整数： 源代码： 顶级编码器 A0纸： 源代码： 数据结构游乐场 BinaryTree：二叉树实现源代码： LinkedList：简单的链表实现源代码...
(Java) 汉诺塔、八皇后、迷宫等经典递归问题
安逸
02-26 403
递归经典问题、汉诺塔、八皇后、猴子吃桃、迷宫问题。
javascript实现汉诺塔动画效果
weixin_34216196的博客
06-02 484
javascript实现汉诺塔动画效果 当初以为不用html5也很简单，踩了javascript单线程的大坑后终于做出来了，没事可以研究下，对理解javascript的执行过程还是很有帮助的，代码很烂大家凑合着看。 &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;Tower of Hanoi...
8皇后位操作解法
白橙纸的不知道什么
08-28 428
#include <iostream> using namespace std; long sum = 0; //用来记录皇后放置成功的不同布局数 long upperlim = (1 << 8) - 1; //这是八皇后的位置 //试探算法从最右边的列开始 void test(long row, long ld, long rd){ if (row == upperlim){
Java基础记忆12（八皇后算法和五子棋玩法）
zh_tnis的博客
08-01 428
首先，在国际象棋中。八皇后是8*8棋盘，其中皇后可以直线行走，可以斜线行走，不分上下左右格数的。 附可行摆法： 所以，可归纳问题的条件为，8皇后之间需满足： 1.不在同一行上 2.不在同一列上 3.不在同一斜线上 4.从第一行第一个开始往右走，对整行和整列和整个斜线看...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值