八皇后问题(回溯)

public class Queen {
    
    int QUEEN_COUNT = 8;    //随便你定义几个皇后了,你可以循环产生a个到b个皇后的解
    static final int EMPTY = 0;  //如果count[x][y] == EMPTY ,则可以放置皇后;反之,其正上方或斜上方必己放置皇后
    int[][] count = new int[QUEEN_COUNT][QUEEN_COUNT]; //
    int[] QueenIndex = new int[QUEEN_COUNT]; //第index行的皇后放置位置是QueenIndex [index]
    int resultCount = 0; //记录皇后放置方法的数量
    
    public void putQueenIndex(int index) {
        int row = index;
        for (int col = 0; col < QUEEN_COUNT; col++) {
            if (count[row][col] == EMPTY) { //该位置可以放置皇后
                for (int iRow = row+ 1; iRow < QUEEN_COUNT; iRow++) { //增加该位置的正下面/斜下面的count,使之不为0
                    count[iRow][col]++;
                    if ((col - iRow + row) >= 0) {
                        count[iRow][col - iRow + row]++;
                    }
                    if ((col + iRow - row) < QUEEN_COUNT) {
                        count[iRow][col + iRow - row]++;
                    }
                }
                QueenIndex[row] = col;
                if (row == QUEEN_COUNT - 1) { //第QUEEN_COUNT个皇后己放置好,打印出这种皇后布局
                    print(++resultCount);
                } else { //继续放置下一行的皇后
                    putQueenIndex(row + 1);
                }
                for (int iRow = row+ 1; iRow < QUEEN_COUNT; iRow++) { //回溯,在此行的皇后不放此列col ,恢复该位置的正下面/斜下面的count
                    count[iRow][col]--;
                    if ((col - iRow + row) >= 0) {
                        count[iRow][col - iRow + row]--;
                    }
                    if ((col + iRow - row) < QUEEN_COUNT) {
                        count[iRow][col + iRow - row]--;
                    }
                }
            }
        }
        if (row == 0) { 
            System.out.println(QUEEN_COUNT + "皇后共有 " + resultCount + " 个解");
        }
    }
    
    public void print(int n) { //打印皇后布局
        System.out.println(QUEEN_COUNT + "皇后的第 " + n + " 个解:");
        for (int i = 0; i < QUEEN_COUNT; i++) {
            for (int j = 0; j < QUEEN_COUNT; j++) {
                System.out.print(QueenIndex[i] == j ? " * " : " - ");
            }
            System.out.println();
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        new Queen().putQueenIndex(0);
    }
}

代码运行结果:

时间: 2024-10-22 09:40:58

八皇后问题(回溯)的相关文章

八皇后,回溯与递归(Python实现)

八皇后,回溯与递归(Python实现) 八皇后问题是十九世纪著名的数学家高斯1850年提出 .以下为python语言的八皇后代码,摘自<Python基础教程>,代码相对于其他语言,来得短小且一次性可以打印出92种结果.同时可以扩展为九皇后,十皇后问题. 问题:在一个8*8棋盘上,每一行放置一个皇后旗子,且它们不冲突.冲突定义:同一列不能有两个皇后,每一个对角线也不能有两个皇后.当然,三个皇后也是不行的,四个也是不行的,凭你的智商应该可以理解吧. 解决方案:回溯与递归. 介绍: 1.回溯法 回溯

2、八皇后问题——回溯法

/** * */ package unit1; /** * @author * @version 创建时间:2015-10-30 下午02:55:24 类说明 */ public class EightQueensNotRecursive { private static final boolean AVAILABLE = true; private int squares = 16, norm = squares - 1; private int positionInRow[] = new i

八皇后问题-回溯法(matlab)

1.问题描述 八皇后问题是十九世纪著名数学家高斯于1850年提出的.问题是:在8*8的棋盘上摆放8个皇后,使其不能互相攻击,即任意的两个皇后不能处在同意行,同一列,或同意斜线上. 2.matlab代码 function PlaceQueen(row,stack,N)%回溯法放置皇后 if row>N PrintQueen(N,stack);%打印棋盘 else for col=1:N stack(row)=col; if row==1||Conflict(row,col,N,stack)%检测是

八皇后之回溯法解决[转]

问题描述: 要在8*8的国际象棋棋盘中放8个皇后,使任意两个皇后都不能互相吃掉.规则是皇后能吃掉同一行.同一列.同一对角线的棋子.如下图即是两种方案: . 解决方案: 8*8的棋盘要摆放8个皇后,且不能同行同列同对角线,那么每行必定会有一个皇后.我们可以设一个数组a用来存放每一行皇后的位置,元素值表示第几列(如a[1]=5表示第一行的皇后处于第五个格).然后只需要求出数组a的值 问题就解决了,下面介绍三种回溯解法: 1.八个for循环.用枚举的办法,八个for循环分别枚举每一行的8个位置,但是我

八皇后,回溯与递归

python语句的八皇后代码,摘自<Python基础教程>,代码相对于其他语言,来得短小且一次性可以打印出92种结果.同时可以扩展为九皇后,十皇后问题. 问题:在一个8*8棋盘上,每一行放置一个皇后旗子,且它们不冲突.冲突定义:同一列不能有两个皇后,每一个对角线也不能有两个皇后.当然,三个皇后也是不行的,四个也是不行的,应该凭智商应该可以理解吧. 解决方案:回溯法和递归法 1 import random 2 3 def conflict(state,col): 4 row=len(state)

八皇后问题-回溯法解

八皇后问题:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同一列或同一斜线上,问有多少种摆法. int g_number = 0;? //多少种摆放方法?void EightQueen(){? ?const int queens = 8;? //棋盘大小?? ?int ColumnIndex[queens];? //列索引?//遍历行? ?for(int i = 0; i < queens; ++ i)?? ? ? ?ColumnIndex[i] = i;

八皇后问题——回溯

经典八皇后问题参考博客http://blog.csdn.net/mbh_1991/article/details/23869459 下面解决八皇后的改版问题: AC代码: 1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 5 char board[10][10]; 6 int board2[10][10]; 7 int num=0; //记录八皇后的个数 8 int res=0; 9 int di

八皇后问题——回溯法(python&amp;&amp;JAVA)

八皇后问题,是一个古老而著名的问题,问题如下: 在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同一列或同一斜线上,问有多少种摆法. 上边是一个8*8的国际棋盘,可以看到棋盘中的每个格子都标有数字.每个数字都是两位,十位数字表示该格子所在的行,而个位数字表示该格子所在的列. 这样不难发现,处在同一行的两个格子其十位数都相同,处在同一列的两个格子其个位数都相同,处在同一斜线的两个格子有:|两个数字个位数的差|=|两个数字十位数的差|. 主要的三个限制条件明白了

八皇后(回溯法)

题目内容 n*n的矩阵,作为棋盘,放置n个皇后,且它们都无法攻击其他皇后,求出放置方法 皇后的攻击方式,沿行.列.对角线都可以攻击其它皇后 基本思想 使用回溯法(穷举法) 所有的回溯问题都是由三个步骤组成:choose.explore.unchoose 因此对每个问题需要知道: choose what?   对于这个问题,我们选择每个字符串 how to explore?对于这个问题,我们对剩余的字符串做同样的事情. unchoose           做相反的操作选择 回溯法步骤 1.Def

八皇后问题 回溯法

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace Demo 8 { 9 class Program 10 { 11 static int num = 8;/*可以随意修改,num是多少解的就是几皇后问题*/ 12 static int[] arr = new int[8