java实现八皇后问题(递归和循环两种方式)

循环方式:

package EightQueens;

public class EightQueensNotRecursive {

private static final boolean AVAILABLE = true;

private int squares = 8, 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 EightQueens;

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-10-24 22:09:39

java实现八皇后问题(递归和循环两种方式)的相关文章

15.输入一颗二元查找树,将该树转换为它的镜像, 即在转换后的二元查找树中,左子树的结点都大于右子树的结点, 用递归和循环两种方法完成树的镜像转换

转载请注明出处:http://www.cnblogs.com/wuzetiandaren/p/4260432.html  声明:现大部分文章为寻找问题时在网上相互转载,此博是为自己做个记录记录,方便自己也方便有类似问题的朋友,本文的思想也许有所借鉴,但源码均为本人实现,如有侵权,请发邮件表明文章和原出处地址,我一定在文章中注明.谢谢. 题目:输入一颗二元查找树,将该树转换为它的镜像, 即在转换后的二元查找树中,左子树的结点都大于右子树的结点, 用递归和循环两种方法完成树的镜像转换. 题目分析:

【剑指offer】递归循环两种方式反转链表

转载请注明出处:http://blog.csdn.net/ns_code/article/details/25737023 本文分别用非递归和递归两种方式实现了链表的反转,在九度OJ上AC. 题目描述: 输入一个链表,反转链表后,输出链表的所有元素.(hint : 请务必使用链表) 输入: 输入可能包含多个测试样例,输入以EOF结束.对于每个测试案例,输入的第一行为一个整数n(0<=n<=1000):代表将要输入的链表的个数.输入的第二行包含n个整数t(0<=t<=1000000)

Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权.因为生产者如果不释放对临界资源的占用权,那么消费者就无法消费队列中的商品,就不会让队列有空间,那么生产者就会一直无限等待下去.因此,一般情况下,当队列满时,会让生产者交出对临界资源的占用权,并进入挂起状态.然后等待消费者消费了商品,然后消费者通知生产者队列有空间了.同样地,当

19、Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权.因为生产者如果不释放对临界资源的占用权,那么消费者就无法消费队列中的商品,就不会让队列有空间,那么生产者就会一直无限等待下去.因此,一般情况下,当队列满时,会让生产者交出对

java的取出map里所有元素的两种方式

/* * 取出map元素的两种方式 */package com.map.test; import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set; public class Test1 { public static void main(String[] args) { // TODO 自动生成的方法存根 Map<Integer,String> mp=new HashMa

【转】BAT启动执行JAVA JAR文件中的MAIN方法的两种方式

A .导出runnable jar 1. Eclipse导出选择Runnable JAR,选择执行的Main入口函数,执行 java -jar Test.jar,Jar包内包含清单文件,记录了引用到的Jar包和所需要执行的main函数所在的类  2. 如上操作会生成一个Test.jar和包含所有引用的第三方库包的Test_lib文件夹,在Jar包同级目录放入写好命令的Bat文件,执行得到 @echo offtitle test echo start exejava -jar hello.jarp

递归和迭代两种方式实现归并排序(Java版)

递归版 package MergeSort; import Utils.SortUtils; /** * 归并排序递归版 * @author liguodong */ public class Demo02 { public static void mergeSort(int[] a){ mSort(a, a, 0, a.length-1); } /** * * @param SR为待排序的数据 * @param TR1为排序之后的数据 * @param s * @param t */ publ

Java多线程:常用的实现多线程的两种方式

之所以说是常用的,是因为通过还可以通过java.util.concurrent包中的线程池来实现多线程.关于线程池的内容,我们以后会详细介绍;现在,先对的Thread和Runnable进行了解.本章内容包括: Thread和Runnable的简介 Thread和Runnable的异同点 Thread和Runnable的多线程的示例 Thread和Runnable简介 Runnable 是一个接口,该接口中只包含了一个run()方法.它的定义如下: public interface Runnabl

Java知识点16 Spring创建IOC容器的两种方式

1.直接得到 IOC 容器对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); 封装起来: 1 public class ApplicationContextUtil { 2 private static ApplicationContext applicationContext = null; 3 public Applicati