关于八皇后问题求解

最新推荐文章于 2024-07-15 22:10:26 发布
最新推荐文章于 2024-07-15 22:10:26 发布
阅读量594 收藏 1
点赞数 5
分类专栏： 八皇后的所有解 n皇后所有解 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaopanJava/article/details/121715115
版权

问题的提出

在1848年，国际西洋棋棋手马克斯·贝瑟尔提出了这样的一个问题，

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

八皇后问题求解

我第一时间就是想到定义一个二维数组去存储这个棋盘 用1表示皇后的位置 0表示没有空位置

//初始化 棋盘 
  int[][] arr = {
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
        };

思路:

  1. 在棋盘中 一行一行的往下走 每一行就放一个 然后判断在当前位置中是否可以放皇后
  2. 写方法判断当前位置 是否可以放皇后
  3. 使用回溯 如果当前位置不可以放皇后的话 就返回上一行 以此类推
  4. 当行数走到第8行时(数组是0-7行)表示已经走到底了 完成了一种摆法

实现

  1. 写方法判断当前位置 是否可以放皇后
 /**
     * 判断行列是否可以
     *
     * @param x  当前的位置的行数
     * @param y  当前的位置的列数
     * @return  true 表示可以放皇后  否则不行
     */
    public static boolean rowAndList(int[][] arr, int x, int y) {
        arr[x][y] = 0;

        //判断行 行不行   int[x][i]
        for (int i = 0; i < 8; i++) {
            if (arr[x][i] == 1 || arr[i][y] == 1) {
                arr[x][y] = 1;
                return false;
            }
        }
        arr[x][y] = 1;
        return true;
    }

    /**
      * 判断行列是否可以
     *
     * @param x  当前的位置的行数
     * @param y  当前的位置的列数
     * @return  true 表示可以放皇后  否则不行
     */
    public static boolean xie(int[][] arr, int x, int y) {

        arr[x][y] = 0;

        // 判断右斜 行不行   int[x][y]
        for (int i = 0; i < 8; i++) {

            if ((x + i) <= 7 && (y + i) <= 7) {
                if (arr[x + i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y - i) >= 0) {
                if (arr[x - i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }

            if ((x + i) <= 7 && (y - i) >= 0) {
                if (arr[x + i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y + i) <= 7) {
                if (arr[x - i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
        }
        arr[x][y] = 1;
        return true;
    }
  1. 回溯
 for (int i = 0; i < arr[index].length; i++) {
 //			将当前位置置为1
            arr[index][i] = 1;
            // 判断当前位置是否可以放1
            if (rowAndList(arr, index, i) && xie(arr, index, i)) {
            //方法名  回溯
                read(index + 1, arr);
            }
            arr[index][i] = 0;
        }
        //终止
        return arr;
  1. 当行数走到第8行时(数组是0-7行)表示已经走到底了 完成了一种摆法
if (index >= arr[0].length) {
            /**
             * 这里可以将所有情况都打印出来
             */
            sum++;
            System.out.println("第"+sum+"种");
            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8; j++) {
                    System.out.print(arr[i][j] + "\t");
                }
                System.out.println();
            }
            System.out.println();
            return;
        }

源代码

package WanBanXueXi.task.day_11_28;


/**
 * 八皇后解法
 * 0 1 0 0 0 0 0 0 0
 * 0 0 0 1 0 0 0 0 0
 * 0 0 0 0 0 1 0 0 0
 * 1 0 0 0 0 0 0 1 0
 * 0 0 1 0 0 0 0 0 0
 * 0 0 0 0 1 0 0 0 0
 * 0 0 0 0 0 0 1 0 0
 * 0 0 0 0 0 0 0 0 1
 * <p>
 * 1 0 0 0 0 0 0 0 0
 * 0 0 1 0 0 0 0 0 0
 * 0 0 0 0 1 0 0 0 0
 * 0 0 0 0 0 0 1 0 0
 * 0 1 0 0 0 0 0 0 0
 * 0 0 0 1 0 0 0 0 0
 * 0 0 0 0 0 1 0 0 0
 * 0 0 0 0 0 0 0 1 0
 * <p>
 * 用下标表示     如果有11    那么  1*都不行     *1都不行   22 33 44 55 66 77 88都不行
 * 如果有23    那么
 * 1.横竖  2* *3 不行
 * 2.右斜  将23都加一   不行    34 45 56 78  减一也不行  12
 * 3.左斜    (32 41 14)不行    前加1 后减一  或 前减1   后减1
 * <p>
 * 回溯
 * <p>
 * 1.穷举法
 * 2.随机法
 */


public class EigthQueenAllPossible {
    static int sum = 0;

    public static void main(String[] args) {
        long begin = System.currentTimeMillis();

        int[][] arr = {
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0},
        };


        read(0,arr);
        System.out.println(sum);
        System.out.println("总耗时:\t" + (System.currentTimeMillis() - begin) + "ms");
    }

    public static void read(int index, int[][] arr) {
        if (index >= arr[0].length) {
            /**
             * 这里可以将所有情况都打印出来
             */
            sum++;
            System.out.println("第"+sum+"种");
            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8; j++) {
                    System.out.print(arr[i][j] + "\t");
                }
                System.out.println();
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < arr[index].length; i++) {
            arr[index][i] = 1;
            if (rowAndList(arr, index, i) && xie(arr, index, i)) {
                read(index + 1, arr);
            }
            arr[index][i] = 0;
        }
        return;
    }

    /**
     * 判断行列是否可以
     *
     * @param x
     * @param y
     * @return
     */
    public static boolean rowAndList(int[][] arr, int x, int y) {
        arr[x][y] = 0;

        //判断行 行不行   int[x][i]
        for (int i = 0; i < 8; i++) {
            if (arr[x][i] == 1 || arr[i][y] == 1) {
                arr[x][y] = 1;
                return false;
            }
        }
        arr[x][y] = 1;
        return true;
    }

    /**
     * 判断斜是否可以
     *
     * @param x
     * @param y
     * @return
     */
    public static boolean xie(int[][] arr, int x, int y) {
//        a[3][2]
        arr[x][y] = 0;

        //todo 判断右斜 行不行   int[x][y]
        for (int i = 0; i < 8; i++) {

            if ((x + i) <= 7 && (y + i) <= 7) {
                if (arr[x + i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y - i) >= 0) {
                if (arr[x - i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }

            if ((x + i) <= 7 && (y - i) >= 0) {
                if (arr[x + i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y + i) <= 7) {
                if (arr[x - i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
        }
        arr[x][y] = 1;
        return true;
    }
}

总结

这种使用回溯 解决的问题 我觉的还是有点难理解的 可以对着程序 慢慢debug 去理解
还有种简单的解法
随机算法
随机生成8个位置的坐标 然后去判断 这一次的结果 是不是成立
我朋友跑了两三个小时也没有跑出来(笑死) (不推荐)

补充n皇后问题 其实只要修改 一些代码就行

N皇后源代码

package WanBanXueXi.task.day_11_28;


/**
 * 八皇后解法
 * 0 1 0 0 0 0 0 0 0
 * 0 0 0 1 0 0 0 0 0
 * 0 0 0 0 0 1 0 0 0
 * 1 0 0 0 0 0 0 1 0
 * 0 0 1 0 0 0 0 0 0
 * 0 0 0 0 1 0 0 0 0
 * 0 0 0 0 0 0 1 0 0
 * 0 0 0 0 0 0 0 0 1
 * <p>
 * 1 0 0 0 0 0 0 0 0
 * 0 0 1 0 0 0 0 0 0
 * 0 0 0 0 1 0 0 0 0
 * 0 0 0 0 0 0 1 0 0
 * 0 1 0 0 0 0 0 0 0
 * 0 0 0 1 0 0 0 0 0
 * 0 0 0 0 0 1 0 0 0
 * 0 0 0 0 0 0 0 1 0
 * <p>
 * 用下标表示     如果有11    那么  1*都不行     *1都不行   22 33 44 55 66 77 88都不行
 * 如果有23    那么
 * 1.横竖  2* *3 不行
 * 2.右斜  将23都加一   不行    34 45 56 78  减一也不行  12
 * 3.左斜    (32 41 14)不行    前加1 后减一  或 前减1   后减1
 * <p>
 * 回溯
 * <p>
 * 1.穷举法
 * 2.随机法
 */


public class EigthQueenAllPossible {
    static int sum = 0;

    public static void main(String[] args) {
        long begin = System.currentTimeMillis();

        //皇后的数量
        int N = 8;

        int[][] arr = new int[N][N];

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = 0;
            }
        }

        read(0,arr);
        System.out.println(sum);
        System.out.println("总耗时:\t" + (System.currentTimeMillis() - begin) + "ms");
    }

    public static void read(int index, int[][] arr) {
        if (index >= arr[0].length) {
            /**
             * 这里可以将所有情况都打印出来
             */
            sum++;
            System.out.println("第"+sum+"种");
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr.length; j++) {
                    System.out.print(arr[i][j] + "\t");
                }
                System.out.println();
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < arr[index].length; i++) {
            arr[index][i] = 1;
            if (rowAndList(arr, index, i) && xie(arr, index, i)) {
                read(index + 1, arr);
            }
            arr[index][i] = 0;
        }
        return;
    }

    /**
     * 判断行列是否可以
     *
     * @param x
     * @param y
     * @return
     */
    public static boolean rowAndList(int[][] arr, int x, int y) {
        arr[x][y] = 0;

        //判断行 行不行   int[x][i]
        for (int i = 0; i < arr.length; i++) {
            if (arr[x][i] == 1 || arr[i][y] == 1) {
                arr[x][y] = 1;
                return false;
            }
        }
        arr[x][y] = 1;
        return true;
    }

    /**
     * 判断斜是否可以
     *
     * @param x
     * @param y
     * @return
     */
    public static boolean xie(int[][] arr, int x, int y) {
//        a[3][2]
        arr[x][y] = 0;

        //todo 判断右斜 行不行   int[x][y]
        for (int i = 0; i < arr.length; i++) {

            if ((x + i) <= arr.length-1 && (y + i) <= arr.length-1) {
                if (arr[x + i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y - i) >= 0) {
                if (arr[x - i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }

            if ((x + i) <= arr.length-1 && (y - i) >= 0) {
                if (arr[x + i][y - i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
            if ((x - i) >= 0 && (y + i) <= arr.length-1) {
                if (arr[x - i][y + i] == 1) {
                    arr[x][y] = 1;
                    return false;
                }
            }
        }
        arr[x][y] = 1;
        return true;
    }
}
小潘66
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
杂题题解~~
qq_58333162的博客
11-06 485
杂题题解1、单词翻转2、导弹拦截3、N皇后问题（dfs)4、迷宫问题 1、单词翻转 #include <iostream> #include <cstring> using namespace std; const int N = 510; char s[N]; int main() { gets(s); int len = strlen(s), sum = 0; s[len] = ' '; for(int i = 0; i <= len; i++) { if
人工智能课程设计——八皇后问题的求解算法比较
qq_33215171的博客
07-29 3477
人工智能课程设计——八皇后问题的求解算法比较八皇后问题的求解算法及步骤分析回溯法——通用的解法回溯法求解八皇后问题具体步骤为：爬山法——经典的解法随机重启爬山法——前进的解法模拟退火法——他山之石A* 算法——启发式解法参考文献 最近暑假有些空闲时间，于是把这学期写的一些课程设计记录下来，如果有需要请自取，原创不易，希望能给各位的学习带来一些方便。 八皇后问题的求解算法及步骤分析 回溯法——通用的...
八皇后问题
qq_44443766的博客
12-02 611
在国际象棋中，皇后是最厉害的棋子，可以横走、直走，还可以斜走。棋手马克斯·贝瑟尔 1848 年提出著名的八皇后问题：即在 8 × 8 的棋盘上摆放八个皇后，使其不能互相攻击 —— 即任意两个皇后都不能处于同一行、同一列或同一条斜线上 现在我们把棋盘扩展到n×n的棋盘上摆放n个皇后，请问该怎么摆？ 请编写程序，输入正整数n，输出全部摆法（棋盘格子空白处显示句点“.”，皇后处显示字母“Q”，每两个字符之间空一格）。 输入格式 正整数n(n>0) 输出格式 若问题有解，则输出全...
八皇后问题理解与解决
weixin_52255304的博客
11-05 2728
一、 问题描述 八皇后问题，即在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果采用穷举法，八皇后问题共计16777216种情况，而且不能只调整有冲突的位置，只能按照既定的枚举顺序解得全部的解。因此，直到在计算机出现后，我们才可以利用其强大的计算能力迅速解决该问题。 二、 实验目标 通过python语言，使..
八皇后问题（启发式搜索）
qq_49392169的博客
10-26 2531
八皇后问题是回溯算法的典型案例，在回溯法中，常常是盲目搜索，耗费过多的搜索时间。在本次实验中，使用了启发式搜索，搜索时不是任取一个分支，而是选择最佳的分支往下搜索。 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 一、 初始化参数： n：代表皇后的个数，因为规定每行放置一个皇后，所以也可以理解为行数。 checkboard：代表最后呈现出来的矩阵，这里用‘0’...
八皇后问题求解
05-06
八皇后问题是一个经典的问题，在棋盘上放置八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。这个问题在计算机科学中被广泛用来教授递归算法和回溯法。下面将详细介绍八皇后问题的...
八皇后问题回溯求解 matlab
08-05
用回溯求解法求解八皇后问题，经典问题matlab实现，欢迎大家下载
c代码-八皇后问题求解
07-14
c代码-八皇后问题求解
C++实现八皇后问题的方法
12-26
本文实例展示了C++实现八皇后问题的方法，是数据结构与算法中非常经典的一个算法。分享给大家供大家参考之用。具体方法如下： 一般在八皇后问题中，我们要求解的是一个8*8的国际象棋棋盘中，放下8个皇后且互相不能...
MOOC清华《程序设计基础》第5章第2题：破损棋盘的八皇后问题
sunshineman1986的博客
07-15 770
题目描述 8X8的国际象棋棋盘上被挖了一些洞，这些洞不能放棋子，求八皇后问题的摆放方案，输出一种方案即可 输入格式 棋盘用.表示正常格子，用#表示被挖掉的洞，一共8行8列 输出格式 输出从上到下的每一行的皇后所在列号（1-8） 注意：只输出列号，只输出列号，最后的输出应该只是8个数字，第i个数字表示第i行的皇后在第几列，中间以空格隔开。 样例输入 ...
【人工智能】八皇后问题-启发式求解
热门推荐
jiange_zh的博客
10-11 1万+
摘要八皇后问题是回溯算法的典型案例，在回溯法中，常常是盲目搜索，耗费过多的搜索时间。在本次实验中，使用了启发式搜索，搜索时不是任取一个分支，而是选择最佳的分支往下搜索。通过定义状态空间、操作规则、搜索策略，我们可以清晰快速地得到原问题的一个解。导言八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个
机器学习实战1：8种人工智能算法求解八皇后问题
FRIGIDWINTER的博客
10-03 3015
八皇后问题一直是AI的入门经典问题，本文用8种人工智能算法攻克它！
棋盘挑战（八皇后类似问题）题解 【DFS】
Jacksqh的博客
01-26 484
文章目录棋盘挑战分析代码运行结果 棋盘挑战 给定一个 N×N 的棋盘，请你在上面放置 N 个棋子，要求满足： 每行每列都恰好有一个棋子 每条对角线上都最多只能有一个棋子 1 2 3 4 5 6 ------------------------- 1 | | O | | | | | ------------------------- 2 | | | | O | | | ------------------------- 3 |
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 224
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 457
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 245
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
最新发布
2201_76027754的博客
07-15 786
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 482
摩尔投票算法的介绍以及相关例题的讲解
八皇后问题求解的流程图
05-29
以下是八皇后问题的求解流程图： ![八皇后问题求解流程图](https://i.imgur.com/3TQ6qJF.png) 解释： 1. 从第一行开始，依次尝试在每一列放置皇后，直到找到一个合法的位置。 2. 如果当前行找到了合法的位置，就...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值