原文地址:https://www.cnblogs.com/newflydd/p/5091646.html
八皇后問題,是一個古老而著名的問題,是回溯算法的典型案例。該問題是國際西洋棋棋手馬克斯·貝瑟爾於1848年提出:在8×8格的國際象棋上擺放八個皇后,使其不能互相攻擊,即任意兩個皇后都不能處於同一行、同一列或同一斜線上,問有多少種擺法。 高斯認爲有76種方案。1854年在柏林的象棋雜誌上不同的作者發表了40種不同的解,後來有人用圖論的方法解出92種結果。計算機發明後,有多種計算機語言可以解決此問題。———以上節選自百度百科。
算法思考,初步思路:
構建二維int或者short型數組,內存中模擬棋盤
chess[r][c]=0表示:r行c列沒有皇后,chess[r][c]=1表示:r行c列位置有一個皇后
從第一行第一列開始逐行擺放皇后
依題意每行只能有一個皇后,遂逐行擺放,每行一個皇后即可
擺放後立即調用一個驗證函數(傳遞整個棋盤的數據),驗證合理性,安全則擺放下一個,不安全則嘗試擺放這一行的下一個位置,直至擺到棋盤邊界
當這一行所有位置都無法保證皇后安全時,需要回退到上一行,清除上一行的擺放記錄,並且在上一行嘗試擺放下一位置的皇后(回溯算法的核心)
當擺放到最後一行,並且調用驗證函數確定安全後,累積數自增1,表示有一個解成功算出
驗證函數中,需要掃描當前擺放皇后的左上,中上,右上方向是否有其他皇后,有的話存在危險,沒有則表示安全,並不需要考慮當前位置棋盤下方的安全性,因爲下面的皇后還沒有擺放
回溯算法的天然實現是使用編譯器的遞歸函數,但是其性能令人遺憾
下面我們使用上面的思路初步實現8皇后的問題解法,並且將所有解法打印出來,供我們驗證正確性
import java.util.Date;
/**
* 在8×8格的國際象棋上擺放八個皇后,使其不能互相攻擊,
* 即任意兩個皇后都不能處於同一行、同一列或同一斜線上,問有多少種擺法。
* 下面使用遞歸方法解決
* @author [email protected]
*
*/
public class EightQueen {
private static final short N=8; //使用常量來定義,方便之後解N皇后問題
private static int count=0; //結果計數器
public static void main(String[] args) {
Date begin =new Date();
//初始化棋盤,全部置0
short chess[][]=new short[N][N];
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
chess[i][j]=0;
}
}
putQueenAtRow(chess,0);
Date end =new Date();
System.out.println("解決 " +N+ " 皇后問題,用時:" +String.valueOf(end.getTime()-begin.getTime())+ "毫秒,計算結果:"+count);
}
private static void putQueenAtRow(short[][] chess, int row) {
/**
* 遞歸終止判斷:如果row==N,則說明已經成功擺放了8個皇后
* 輸出結果,終止遞歸
*/
if(row==N){
count++;
System.out.println("第 "+ count +" 種解:");
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
System.out.print(chess[i][j]+" ");
}
System.out.println();
}
return;
}
short[][] chessTemp=chess.clone();
/**
* 向這一行的每一個位置嘗試排放皇后
* 然後檢測狀態,如果安全則繼續執行遞歸函數擺放下一行皇后
*/
for(int i=0;i<N;i++){
//擺放這一行的皇后,之前要清掉所有這一行擺放的記錄,防止污染棋盤
for(int j=0;j<N;j++)
chessTemp[row][j]=0;
chessTemp[row][i]=1;
if( isSafety( chessTemp,row,i ) ){
putQueenAtRow(chessTemp,row+1);
}
}
}
private static boolean isSafety(short[][] chess,int row,int col) {
//判斷中上、左上、右上是否安全
int step=1;
while(row-step>=0){
if(chess[row-step][col]==1) //中上
return false;
if(col-step>=0 && chess[row-step][col-step]==1) //左上
return false;
if(col+step<N && chess[row-step][col+step]==1) //右上
return false;
step++;
}
return true;
}
}
輸出結果:
需要打印棋盤時,耗時34毫秒,再看一看不需要打印棋盤時的性能:
耗時2毫秒,性能感覺還可以。
你以爲到這兒就結束了嗎?高潮還沒開始,下面我們來看看這種算法解決9、10、11…15皇后問題的性能
稍微變動一下代碼,循環打印出各個解的結果,如下圖所示:
當我開始嘗試解決16皇后問題時,發現時間複雜度已經超出我的心裏預期,最終沒讓它繼續執行下去。
上網一查N皇后的國際記錄,已經有科研單位給出了25皇后的計算結果,耗時暫未可知
我們的程序跑16皇后已經無能爲力,跑15皇后已經捉襟見肘(87秒)
中國的一些算法高手能在100秒內跑16皇后,可見上面的算法效率只能說一般,辣麼,該如何改進呢?
我們發現二維棋盤數據在內存中浪費嚴重,全是0和1的組成,同時每次遞歸時使用JAVA的clone函數克隆一個新的棋盤,消耗進一步擴大,這裏面一定有改進的方案。
我們考慮將二維數組使用一維數組代替,將一維數組的下標數據利用起來,模仿棋盤結構,如chess[R]=C時,表示棋盤上R行C列有一個皇后
這樣程序的空間效率會得到迅速提高,同時二維數據改變成一維數據後的遍歷過程也會大爲縮減,時間效率有所提高,下面貼出代碼:
import java.util.Date;
public class EightQueen2 {
private static final short K=15; //使用常量來定義,方便之後解N皇后問題
private static int count=0; //結果計數器
private static short N=0;
public static void main(String[] args) {
for(N=9;N<=K;N++){
Date begin =new Date();
/**
* 初始化棋盤,使用一維數組存放棋盤信息
* chess[n]=X:表示第n行X列有一個皇后
*/
short chess[]=new short[N];
for(int i=0;i<N;i++){
chess[i]=0;
}
putQueenAtRow(chess,(short)0);
Date end =new Date();
System.out.println("解決 " +N+ "皇后問題,用時:" +String.valueOf(end.getTime()-begin.getTime())+ "毫秒,計算結果:"+count);
}
}
private static void putQueenAtRow(short[] chess, short row) {
/**
* 遞歸終止判斷:如果row==N,則說明已經成功擺放了8個皇后
* 輸出結果,終止遞歸
*/
if(row==N){
count++;
// System.out.println("第 "+ count +" 種解:");
// for(int i=0;i<N;i++){
// for(int j=0;j<N;j++){
// System.out.print(chess[i][j]+" ");
// }
// System.out.println();
// }
return;
}
short[] chessTemp=chess.clone();
/**
* 向這一行的每一個位置嘗試排放皇后
* 然後檢測狀態,如果安全則繼續執行遞歸函數擺放下一行皇后
*/
for(short i=0;i<N;i++){
//擺放這一行的皇后
chessTemp[row]=i;
if( isSafety( chessTemp,row,i ) ){
putQueenAtRow(chessTemp,(short) (row+1));
}
}
}
private static boolean isSafety(short[] chess,short row,short col) {
//判斷中上、左上、右上是否安全
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;
}
}
運算結果:
可以看到所有結果的耗時縮短了一倍有餘,這無疑是一次算法的進步