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 int[squares];
    private int p = -1;
    private boolean[] rows = new boolean[squares];
    private boolean[] column = new boolean[squares];
    private boolean[] leftDiagonal = new boolean[2 * squares - 1];
    private boolean[] rightDiagonal = new boolean[2 * squares - 1];
    private static int howMany = 0;

    public EightQueensNotRecursive() {
        // To complete the initialization work for the
        // column,leftDiagonal,rigthDiagonal.
        for (int i = 0; i < squares; i++) {
            rows[i] = AVAILABLE;
            column[i] = AVAILABLE;
            positionInRow[i] = -1;
        }
        for (int i = 0; i < 2 * squares - 1; i++) {
            leftDiagonal[i] = AVAILABLE;
            rightDiagonal[i] = AVAILABLE;
        }

    }

    public void printResults(int[] columns) {
        int row, col;
        System.out.println("八皇后问题的第 " + howMany + " 种解法");
        System.out.print("八皇后问题的结果为:");
        for (int e : columns) {
            System.out.print(e);
        }
        System.out.println("\n具体的图示如下图所示:");
        for (row = 0; row < squares; row++) {
            for (col = 0; col < squares; col++) {
                if (col == positionInRow[row]) {
                    System.out.print("@");
                } else {
                    System.out.print("*");
                }
            }
            System.out.println();
        }
        System.out.println();
    }

    public void putQueen() {
        int row = 0, col;
        while (true) {
            for (col = p + 1; col < squares; col++) {
                if (rows[row] == AVAILABLE && column[col] == AVAILABLE
                        && leftDiagonal[row + col] == AVAILABLE
                        && rightDiagonal[row - col + norm] == AVAILABLE) {
                    break;
                }
            }
            // 在当前的行里面找到了可以放置皇后的位置
            if (col < squares) {
                rows[row] = !AVAILABLE;
                column[col] = !AVAILABLE;
                leftDiagonal[row + col] = !AVAILABLE;
                rightDiagonal[row - col + norm] = !AVAILABLE;
                positionInRow[row] = col;
                p = col;
            } else// 如果当前行没办反放置皇后了,那么回溯
            {
                if (row > 0)// 到前一行
                {
                    row--;
                    p = positionInRow[row];
                    rows[row] = AVAILABLE;
                    column[p] = AVAILABLE;
                    leftDiagonal[row + p] = AVAILABLE;
                    rightDiagonal[row - p + norm] = AVAILABLE;
                    positionInRow[row] = -1;
                    continue;
                } else {
                    break;
                }
            }
            if (row == squares - 1) {
                howMany += 1;
                printResults(positionInRow);
                p = positionInRow[row];
                rows[row] = AVAILABLE;
                column[p] = AVAILABLE;
                leftDiagonal[row + p] = AVAILABLE;
                rightDiagonal[row - p + norm] = AVAILABLE;
                positionInRow[row] = -1;
                continue;
            } else {
                row++;
                p = -1;
                continue;
            }
        }
    }

    public static void main(String args[]) {
        EightQueensNotRecursive eightQueens = new EightQueensNotRecursive();
        eightQueens.putQueen();
        System.out.println("皇后问题一共有" + howMany + "种解法");
    }

}
/**
 *
 */
package unit1;

/**
 * @author
 * @version 创建时间:2015-10-30 下午02:41:57 类说明
 */
public class EightQueensRecursive {
    private static final boolean AVAILABLE = true;
    private int squares = 8, norm = squares - 1;
    private int positionInRow[] = new int[squares];
    private boolean[] column = new boolean[squares];
    private boolean[] leftDiagonal = new boolean[2 * squares - 1];
    private boolean[] rightDiagonal = new boolean[2 * squares - 1];
    private static int howMany = 0;

    public EightQueensRecursive() {
        // To complete the initialization work for the
        // column,leftDiagonal,rigthDiagonal.
        for (int i = 0; i < squares; i++) {
            column[i] = AVAILABLE;
            positionInRow[i] = -1;
        }
        for (int i = 0; i < 2 * squares - 1; i++) {
            leftDiagonal[i] = AVAILABLE;
            rightDiagonal[i] = AVAILABLE;
        }
    }

    public void printResults(int[] columns) {
        int row, col;
        System.out.println("八皇后问题的第 " + howMany + " 种解法");
        System.out.print("八皇后问题的结果为:");
        for (int e : columns) {
            System.out.print(e);
        }
        System.out.println("\n具体的图示如下图所示:");
        for (row = 0; row < squares; row++) {
            for (col = 0; col < squares; col++) {
                if (col == positionInRow[row]) {
                    System.out.print("@");
                } else {
                    System.out.print("*");
                }
            }
            System.out.println();
        }
        System.out.println();
    }

    public void putQueen(int row) {
        // 如果前面已经得到了一个可行解
        for (int i = 0; i < squares; i++) {
            if (row > squares - 1)
                break;
            if (column[i] == AVAILABLE && leftDiagonal[row + i] == AVAILABLE
                    && rightDiagonal[row - i + norm] == AVAILABLE) {
                positionInRow[row] = i;
                column[i] = !AVAILABLE;
                leftDiagonal[row + i] = !AVAILABLE;
                rightDiagonal[row - i + norm] = !AVAILABLE;
                if (row < squares - 1) {
                    putQueen(row + 1);
                } else {
                    howMany += 1;
                    printResults(positionInRow);
                }
                column[i] = AVAILABLE;
                leftDiagonal[row + i] = AVAILABLE;
                rightDiagonal[row - i + norm] = AVAILABLE;
            }
        }
    }

    public static void main(String args[]) {
        EightQueensRecursive eightQueens = new EightQueensRecursive();
        eightQueens.putQueen(0);
        System.out.println("皇后问题一共找到了 " + howMany + "组解。");
    }
}
时间: 2024-11-08 22:10:33

2、八皇后问题——回溯法的相关文章

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

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

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

八皇后(回溯法)

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

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

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

八皇后问题 回溯法

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

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

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

N皇后问题--回溯法 (循环递归)

N皇后问题 问题描述:N皇后问题是一个经典的问题,在一个N*N的棋盘上放置N个皇后,每行一个并使其不能互相攻击(同一行.同一列.同一斜线上的皇后都会自动攻击) 思路 (回溯法,循环递归):0. 初始化棋盘(全部为0)1. 依次将第一列棋子置为12. 放完棋子执行横向,纵向,斜向的update,把不能放棋子的位置置为23. 从第二列棋子开始,递归执行4. 执行到最后一列,退出递归5. 执行第一列的第二个棋子 实现: var N = 4; Array.prototype.count = functi

八皇后,回溯与递归

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