上两篇博客html
研究了递归方法实现回溯,解决N皇后问题,下面咱们来探讨一下非递归方案java
实验结果使人仍是有些失望,原来非递归方案的性能并不比递归方案性能高算法
代码以下:安全
package com.newflypig.eightqueen; import java.util.Date; /** * 使用循环控制来实现回溯,解决N皇后 * @author newflydd@189.cn * Time : 2016年1月1日 下午9:37:32 */ public class EightQueen4 { private static short K=15; private static short N=0; private static boolean dead=false; //下方走到了死路 public static void main(String[] args) { for (N = 9; N <= K; N++) { Date begin = new Date(); dead=false; long count = 0; /** * -2:初始状态,还没有摆放 -1:开始尝试摆放 0到N-1:皇后安全的摆放在这一列的哪一行 */ short[] chess = new short[N]; for (short i = 1; i < N; i++) chess[i] = -2; OUT: while (chess[0] != -2) { if (dead) { /** * 若是下方的皇后已经摆无可摆,已经走到死路 则要将当前最后一个安全的皇后右移 右移成功后,判断安全性 * 安全:dead清除,继续外部循环 不安全,则继续右移,直至边界溢出,再次死路 */ while (moveStep(chess)) { if (isSafety(chess)) { dead = false; continue OUT; } } } else { /** * 若是当前状态下的安全棋盘并无接受到下方传来的死路信号 则须要进一步探测下一行的摆放位置 */ short row = getRow(chess); chess[row + 1] = -1; // 准备对下一层摆放皇后 while (moveStep(chess)) { if (isSafety(chess)) { if (row + 1 == N - 1) { // 若是最后一行找到了一个可能解 count++; // 计数+1 /** * 找到解之后,dead设为死路,最后一行清掉皇后,同时倒数第二行也要清掉皇后 */ dead = true; chess[N - 1] = -2; continue OUT; } continue OUT; } } } } Date end = new Date(); System.out.println("解决 " + N + "皇后问题,用时:" + String.valueOf(end.getTime() - begin.getTime()) + "毫秒,计算结果:" + count); } } private static boolean moveStep(short[] chess) { short row=getRow(chess); if(chess[row]+1>=N){ /** * 摆到边界,清空当前行的摆放记录,标志死路 */ chess[row]=-2; dead=true; return false; } chess[row]=(short) (chess[row]+1); return true; } private static short getRow(short[] chess) { short row=(short) (N-1); while(chess[row]==-2){ row--; } return row; } private static boolean isSafety(short[] chess) { short row=getRow(chess); short col=chess[row]; //判断中上、左上、右上是否安全 short step=1; for(short i=(short) (row-1);i>=0;i--){ if(chess[i]==col) //中上 return false; if(chess[i]==col-step) //左上 return false; if(chess[i]==col+step) //右上 return false; step++; } return true; } }
程序中定义了全局变量dead死路标志,告诉循环何时须要回溯,何时须要继续深搜数据结构
getRow() 函数返回当前最后摆放皇后的行号,每次摆放皇后和判断安全性时都要调用,因此显得性能偏低多线程
下面取消了getRow()函数,使用全局变量row来表示已经摆到那一行的皇后了,用一个小小的变量空间换了一部分时间:函数
package com.newflypig.eightqueen; import java.util.Date; /** * 使用循环控制来实现回溯,解决N皇后 * 开辟两个变量控制行和列,避免没必要要的计算,空间换时间 * @author newflydd@189.cn * Time : 2016年1月1日 下午9:37:32 */ public class EightQueen5 { private static short K=15; private static short N=0; private static boolean dead=false; //下方走到了死路 private static short row=0; public static void main(String[] args) { for (N = 9; N <= K; N++) { Date begin = new Date(); row=0; dead=false; long count = 0; /** * -2:初始状态,还没有摆放 -1:开始尝试摆放 0到N-1:皇后安全的摆放在这一列的哪一行 */ short[] chess = new short[N]; for (short i = 1; i < N; i++) chess[i] = -2; OUT: while (chess[0] != -2) { if (dead) { /** * 若是下方的皇后已经摆无可摆,已经走到死路 则要将当前最后一个安全的皇后右移 右移成功后,判断安全性 * 安全:dead清除,继续外部循环 不安全,则继续右移,直至边界溢出,再次死路 */ while (moveStep(chess)) { if (isSafety(chess)) { dead = false; continue OUT; } } } else { /** * 若是当前状态下的安全棋盘并无接受到下方传来的死路信号 则须要进一步探测下一行的摆放位置 */ chess[++row] = -1; // 准备对下一层摆放皇后 while (moveStep(chess)) { if (isSafety(chess)) { if (row == N - 1) { // 若是最后一行找到了一个可能解 count++; // 计数+1 /** * 找到解之后,dead设为死路,最后一行清掉皇后 */ dead = true; chess[N - 1] = -2; row--; continue OUT; } continue OUT; } } } } Date end = new Date(); System.out.println("解决 " + N + "皇后问题,用时:" + String.valueOf(end.getTime() - begin.getTime()) + "毫秒,计算结果:" + count); } } private static boolean moveStep(short[] chess) { if(chess[row]+1>=N){ /** * 摆到边界,清空当前行的摆放记录,标志死路 */ chess[row]=-2; row--; dead=true; return false; } chess[row]=(short) (chess[row]+1); return true; } private static boolean isSafety(short[] chess) { short col=chess[row]; //判断中上、左上、右上是否安全 short step=1; for(short i=(short) (row-1);i>=0;i--){ if(chess[i]==col) //中上 return false; if(chess[i]==col-step) //左上 return false; if(chess[i]==col+step) //右上 return false; step++; } return true; } }
最终的执行效率为:性能
这跟咱们第一篇博客的递归调用的效率:spa
仍是有些差距,因此算法届大张旗鼓的所谓“递归影响性能”的说法并不存在,至少在这个问题上有待探讨线程
最后我还想再实现如下多线程解决N皇后的问题
由于我发现不管用不用递归,个人N皇后程序跑起来的时候,CPU使用率都在15%如下
可能用了JAVA的缘故,虚拟机沙盒有限制,并且是多核的CPU,暂时也没搞明白为何不能发挥更高的CPU使用率
最后我将用多线程再次尝试更高的程序性能,看看可否有突破。