精华内容
下载资源
问答
  • 八皇后问题java

    2016-05-31 08:50:10
    八皇后问题java
  • 八皇后问题Java

    2015-05-04 21:58:04
    八皇后Java解法,鉴于大部分八皇后都是用C和C++写的给一个Java代码供参考
  • 八皇后问题JAVA

    2020-12-15 00:29:11
    八皇后问题 是一个古老而著名的问题,是回溯算法的典型案例。 该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出的,在8*8格的国际象棋上摆放八个皇后;使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或...

    题目描述

    八皇后问题
    是一个古老而著名的问题,是回溯算法的典型案例。
    该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出的,在8*8格的国际象棋上摆放八个皇后;使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上;
    问有多少种摆法, 输出所有可能的解?

    代码

    public class Main19 {
        private static int max = 8;
        private static int[] array = new int[max];
        private static int count;
        //题意,输出的序号
        private static int ca = 1;
    
        public static void main(String[] args) {
            count = 0;
            check(0);
    
    
        }
    
        public static void check(int n) {
            if (n == max) {
                //满足一次累加一次
                count++;
                //皇后数组每行的列坐标的下标
                int index = 0;
                //题意输出
                System.out.println("Case " + ca++ + ":");
                for (int i = 0; i < max; i++) {
                    for (int j = 0; j < max; j++) {
                        if (j == array[index]) {
                            System.out.print("Q" + " ");
                        } else {
                            System.out.print("." + " ");
                        }
                    }
                    index++;
                    System.out.println();
                }
                System.out.println();
                return;
            }
    
            //回溯,找完一个,最后一个皇后重新找位置。
            for (int i = 0; i < max; i++) {
                array[n] = i;
                if (judge(n)) {
                    check(n + 1);
                }
            }
        }
    
        //判断,行默认不会重复,判断列,和对角线
        public static boolean judge(int n) {
            for (int i = 0; i < n; i++) {
                if (array[i] == array[n] || n - i == Math.abs(array[n] - array[i])) {
                    return false;
                }
            }
            return true;
        }
    }
    
    
    展开全文
  • 八皇后问题 java

    2018-03-29 18:12:59
    public class EightQueue { //检查指定的行和列位置是否可以放置皇后,如果可以放置返回1,否则返回0; public static int check(int a[][],int row,int col) { int i,j; //判断行 for(i =1;i;i++) { if
    
    public class EightQueue {
        //检查指定的行和列位置是否可以放置皇后,如果可以放置返回1,否则返回0;
        public static int check(int a[][],int row,int col) {
            int i,j;
            //判断行
            for(i =1;i<col;i++) {
                if(a[row][i] == 1) return 0;
            }
            //判断列
            for(i=1;i<row;i++) {
                if(a[i][col] == 1) return 0;            
            }
            //判断对角线
            //判断↗的对角线
            for(i=row-1,j=col+1;i>0&&j<9;i--,j++) {
                if(a[i][j] == 1) return 0;
            }
            //判断↘的对角线
            for(i=row-1,j=col-1;i>0&&j>0;i--,j--) {
                if(a[i][j] == 1) return 0;
            }//通过上面检查没问题,说明该位置可以放置皇后
            return 1;
        }
        //获取指定行的皇后所在的列数
        public static int GetColumnAtRow(int a[][],int row) {
            int i=0;
            for(i=1;i<9;i++) {
                if(a[row][i] == 1) 
                    return i;
    
        }
            return -1;
        }
        //放置8个皇后的函数
        public static int SetQueen(int a[][],int row,int col) {
            if(row == 9)//如果到了最后一行的下一行,表示皇后已经全部放置完成。
                return 1;
            //如果到了最后一列之后
            if(col == 9) {
                if(row == 1) return 0;//如果到了第一行的最后一列,还是放不下,那就不能完成任务。 
                //如果不是第一行就回溯到上一行的位置从下一列的位置开始放置。先要清空原来皇后的位置。(获取上一行皇后的位置)
                int c = GetColumnAtRow(a,row-1);
                a[row-1][c] = 0;//取消上一行皇后的放置位置
                return SetQueen(a,row-1,c+1);
            }
            //检查该位置是否可以放置皇后。
            if(check(a,row,col) == 1)
            {
                a[row][col] = 1;
                //递归调用,放置下一行的皇后。
                return SetQueen(a,row+1,1);
            }
            else 
                //如果当前位置不能放,就往下一列进行试探。
                return SetQueen(a,row,col+1);
        }
        public static void main(String [] args) {
            int [][] a = new int[9][9];//用于保存八个皇后放置的位置的记录。
            int i,j;
            if(SetQueen(a,1,1) == 1) {
                System.out.println("皇后放置完成");
                for(i=1;i<9;i++) {
                    for(j=1;j<9;j++) {
                        if(a[i][j] == 1) System.out.print("@ ");
                        else System.out.print("- ");
                    }
                    System.out.println();
                }
    
            }
        }
    
    }
    
    展开全文
  • 八皇后问题 JAVA

    2019-03-23 18:31:57
    public static int[][] arry=new int[8][8];//棋盘,放皇后 public static int map=0;//存储方案结果数量 public static void main(String[] args) { // TODO Auto-... System.out.println("八皇后问题");...
    public static int[][] arry=new int[8][8];//棋盘,放皇后
    public static int map=0;//存储方案结果数量
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        System.out.println("八皇后问题");
        findQueen(0);
        System.out.println("八皇后问题共有:"+map+"种可能");
    }
    
    public static void findQueen(int i){//寻找皇后节点
        if(i>7){//八皇后的解  
            map++;
            print();//打印八皇后的解
            return;
        }
        
        for(int m=0;m<8;m++){//深度回溯,递归算法
            if(check(i,m)){//检查皇后摆放是否合适
                arry[i][m]=1;
                findQueen(i+1);
                arry[i][m]=0;//清零,以免回溯的时候出现脏数据
                }
        }   
    }
    
    public static boolean check(int k,int j){//判断节点是否合适
        for(int i=0;i<8;i++){//检查行列冲突
             if(arry[i][j]==1){
                    return false;
             }
        }
        for(int i=k-1,m=j-1; i>=0 && m>=0; i--,m--){//检查左对角线
            if(arry[i][m]==1){
                    return false;
            }
        }
        for(int i=k-1,m=j+1; i>=0 && m<=7; i--,m++){//检查右对角线
            if(arry[i][m]==1){
                    return false;
            }
        }
        return true;
    }
    
    public static void print(){//打印结果
        System.out.print("方案"+map+":"+"\n");
        for(int i=0;i<8;i++){
            for(int m=0;m<8;m++){
                if(arry[i][m]==1){  
                    System.out.print("o ");
                }
                else{
                        System.out.print("+ ");
                }
            }
            System.out.println();
        }
        System.out.println();
    }

     

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

    2018-03-22 20:04:14
    八皇后java实现。八皇后问题是经典的回溯算法的应用,8x8的棋盘我们可以按行或者按列确定皇后的位置,比如我这边是按行安排皇后的位置,那么堆栈里存放的则是其所在列数。
  • 八皇后问题java解法

    2021-07-01 15:26:13
    八皇后问题 八皇后问题是:在八行八列的格子上放8个皇后(棋子),使得任意两个皇后都攻击不到对方,即使得他们都不在同一行同一列和同一斜线上。 int[] result ;//最终的结果数组 int queenNum;// 皇后的数量,N...

    八皇后问题

    八皇后问题是:在八行八列的格子上放8个皇后(棋子),使得任意两个皇后都攻击不到对方,即使得他们都不在同一行同一列和同一斜线上。

        int[] result ;//最终的结果数组
        int queenNum;// 皇后的数量,N皇后
        int k = 0;
        public void static main(String[] args) {
    
            queenNum = 8;
            result = new int[queenNum];
            questionN(0);
    
        }
    
    //  核心回溯算法
        public void questionN(int n) {
            if(n == queenNum){
                k++;
                Log.e("-----","解法:"+k);
                for(int i = 0;i<queenNum;i++){
                    Log.e("-----","第"+(i+1)+"行放置位置:"+(result[i]+1));
                }
                return ;
            }
    
            for (int i = 0;i<queenNum;i++){
                result[n] = i;
                if(checkValid(result,n)){
                    questionN(n+1);
                }
            }
    
        }
    
    // 检验合法性
        public boolean checkValid(int[] result,int n){
            for(int j = 0;j<n;j++){
                if(result[j] == result[n]){// 是否在同一条直线上
                    return false;
                }else if(Math.abs(result[j]-result[n])==Math.abs(j-n)){//是否在同一条斜线上
                    return  false;
                }
            }
            return true;
        }
    
    展开全文
  • 八皇后问题Java代码

    2010-11-07 21:07:51
    * 八皇后问题Java代码 * * @author Kevin Alps */ public class EightQueen { int queen[][] = new int[8][8]; //保存每个格子的状态,有皇后为1,无皇后为0 int result[] = new int[8]; //保存皇后...
  • 八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或...
  • 1212: 八皇后问题 java

    2020-05-22 23:20:46
    1212: 八皇后问题 " 时间限制 111 秒/Second(s) 内存限制 128128128 兆字节/Megabyte(s) 提交总数 179179179 正确数量 103103103 裁判形式 标准裁判/Standard Judge 我的状态 已经解决 难度 二级 分类标签 递归 博弈...
  • 这是Java语言编写的八皇后问题求解程序的源代码及其输出结果。(能得到全部92种不同的解)
  • 八皇后问题java代码

    千次阅读 2015-05-05 19:46:05
    八皇后问题-回溯法
  • 八皇后问题 java实现

    2019-08-05 16:29:43
    1.问题描述 在国际象棋中,皇后可以横,竖,斜三种走法. (比中国象棋的車还厉害些) 现有n*n的棋盘 要放n个皇后,且使他们相互无法攻击,问有多少种放法.(即棋盘上任意横,竖斜线都只有一个皇后) 2.大概思路: 1.用n*n一...
  • 八皇后问题 八皇后问题是指任何两个皇后不能处在同一行、同一列、同一斜线上,问有多少种摆法。 思路分析: 当取得一个正确解的时候,他会把第一个皇后所在位置的所有解先求出来。比如说:他会把(1,1)这个位置中...
  • 八皇后问题 java代码

    2016-07-23 08:54:02
    具体的结果在tmp.txt文件里面...import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.util.Arrays; i
  • import java.util.Scanner; public class EightQueen { private static int m = 0; //设置皇后的个数 public static int n; //棋盘 public static int[][] pan; //展示棋盘 public static void show() { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,743
精华内容 1,497
关键字:

八皇后问题java

java 订阅