八皇后問題描述

問題： 國際象棋棋盤是8 * 8的方格，每個方格里放一個棋子。皇后這種棋子可以攻擊同一行或者同一列或者斜線（左上左下右上右下四個方向）上的棋子。在一個棋盤上如果要放八個皇后，使得她們互相之間不能攻擊（即任意兩兩之間都不同行不同列不同斜線），求出一種（進一步的，所有）佈局方式。

首先，我們想到遞迴和非遞迴兩類演算法來解決這個問題。首先說說遞迴地演算法。

很自然的，我們可以基於行來做判斷標準。八個皇后都不同行這是肯定的，也就說每行有且僅有一個皇后，問題就在於皇后要放在哪個列。當然八個列下標也都不能有相同，除此之外還要保證斜線上不能有重疊的皇后。

第一個需要解決的小問題就是，如何用數學的語言來表述斜線上重疊的皇后。其實我們可以看到，對於位於(i,j)位置的皇后而言，其四個方向斜線上的格子下標分別是 (i-n,j+n), (i-n,j-n), (i+n,j-n), (i+n,j+n)。當然i和j的±n都要在[0,7]的範圍內，保持不越界。暫時拋開越界限制不管，這個關係其實就是： 目標格子(a,b)和本格子(i,j)在同一條斜線上 等價於 |a - i| == |b - j| 。

然後，從遞迴的思想來看，我們在從第一行開始給每一行的皇后確定一個位置。每來到新的一行時，對本行的所有可能位置（皇后放在這個位置和前面所有已放置的皇后無衝突）分別進行遞迴地深入；若某一行可能的位置數為0，則表明這是一條死路，返回上一層遞迴尋找其他辦法；若來到的這一行是第九行（不存在第九行，只不過是說明前八行都已經正確配置，已經得到一個解決方案），這說明得到解決方案。

可以看到，尋找一行內皇后應該擺放的位置這是個遞迴過程，並且在進入遞迴時，應該要告訴這個過程的東西包括兩個： 1. 之前皇后放置的狀態， 2. 現在是第幾行。

所以，遞迴主體函式可以設計為 EightQueen(board, row)，其中board表示的是當前棋盤的狀態（比如一個二維陣列，0表示未放置，1表示放有皇后的狀態）。另外還可以有一個check(board,pos)，pos可以是一個(x,y)元組，check函式用來返回以當前的board棋盤狀態，如果在pos再放置一個皇后是否會有衝突。

基於上面的想法，初步實現如下：

​
  def check(board,pos):
   # check函式暫時先不實現
   pass
  
  def EightQueen(board,row):
   blen = len(board)
   if row == blen: # 來到不存在的第九行了
   print board
   return True # 一定要return一個True，理由在下面
   for possibleY in range(blen):
   if check(board,(row,possibleY)):
    board[row][possibleY] = 1 # 放置一個Queen
    if not EightQueen(board,row+1): # 這裡其實是本行下面所有行放置皇后的遞迴入口。但是如果最終這條路沒有找到一個解，那麼
    # 此時應該將剛才放置的皇后收回，再去尋找下一個可能的解
    board[row][possibleY] = 0
    else:
    return True
   return False
 

最開始，可能在迴歸返回條件那裡面不會想到要return True，而只是return。對應的，下面主迴圈中放置完Queen之後也只是簡單地遞迴呼叫EightQueen，不會做邏輯判斷。但是很快可以發現這樣做存在一個問題，即當某一層遞迴中for possibleY這個迴圈走完卻沒有找到一個合適的解（即本行無合適位置），此時返回上一行，上一行的possibleY右移一格，此時之前放在這一行的Queen的位置仍然是1。這樣之後本行的所有check肯定都是通不過的。所以我們需要設計一個機制，使得第一個possibleY沒有找到合理的最終解決方案（這裡就加上了一個判斷條件），要右移一格到下一個possibleY時將本格的Queen收回。

這個判斷條件就是如果某層遞迴for possibleY迴圈整個走完未找到結果返回False（EightQueen整個函式最後的返回），上一層根據這個False反饋把前一個Queen拿掉；如果找到了某個結果那麼就可以一路return True回來，結束函式的執行。

另外，如果只是獲取一個解的話，可以考慮在if row == blen的時候，打印出board，然後直接sys.exit(0)。此時就只需要for possibleY迴圈完了之後return一個False就可以了。當然主迴圈中對於遞迴的返回的判斷 if not EightQueen還是需要的。

上面沒有實現check函式。其實仔細想一下，如果按照上面的設想來實現check函式還是有點困難的。比如令 x,y = pos，儘管此時我們只需要去檢查那些行下標小於x的board中的行，但是對於每一行中我們還是要一個個去遍歷，找到相關行中值是1的那個格子（突然發現這個是one- hot模式誒哈哈），然後將它再和x,y這個位置做衝突判斷。所以但是這個check函式複雜度就可能會達到O(n^2)，再套上外面的迴圈，複雜度蹭蹭往上漲。下面是check函式的一個可能的實現：

​
  def check(board,pos):
   x,y = pos
   blen = len(board)
   for i in range(x):
   for j in range(blen):
    if board[i][j] == 1:
    if j == y or abs(j-y) == abs(i-x):
     return False
   return True

其實可以看到，我們花了一層迴圈在尋找某行中的one- hot，那些大量的0值元素是我們根本不關心的。換句話說，對於board這個二維陣列，其實我們真正關心的是每行中one- hot值的下標值。自然我們就可以想到，能不能將board轉化為一個一維陣列，下標本身就代表了board中的某一行，然後值是指這一行中皇后放在第幾列。

如果是這樣的話，那麼程式就需要改造，首先是check函式要根據新的board資料結構做一些調整：

​
  def check(board,row,col):
   i = 0
   while i < row:
   if abs(col-board[i]) in (0,abs(row-i)):
    return False
   i += 1
   return True

可以看到，改變二維陣列board變為一維陣列之後，我們可以在O(1)的時間就確定row行之前每一行擺放的位置，並將其作為參考進行每一行的衝突判斷。

然後是主函式的修改：

​
  def EightQueen(board,row):
   blen = len(board)
   if row == blen: # 來到不存在的第九行了
   print board
   return True
   col = 0
   while col < blen:
   if check(board,row,col):
    board[row] = col
    if EightQueen(board,row+1):
    return True
   col += 1
   return False
  
  def printBoard(board):
   '''為了更友好地展示結果 方便觀察'''
   import sys
   for i,col in enumerate(board):
   sys.stdout.write('□ ' * col + '■ ' + '□ ' * (len(board) - 1 - col))
   print ''

總的結構，和沒修改之前是類似的，只不過在主迴圈中，從上面的possibleY作為遊標去設定 - 去除 一個位置的放置狀態，這種方式改為了簡單的col += 1。改成col+=1的好處就是當某輪遞迴以失敗告終，返回上層遞迴之後，就不用再去特地收回之前放置好的Queen，而是可以直接讓col += 1,。

printBoard函式可以將一維陣列的board狀態很直觀地展現出來：

■ □ □ □ □ □ □ □ □ □ □ □ ■ □ □ □ □ □ □ □ □ □ □ ■ □ □ □ □ □ ■ □ □ □ □ ■ □ □ □ □ □ □ □ □ □ □ □ ■ □ □ ■ □ □ □ □ □ □ □ □ □ ■ □ □ □ □

所有結果

上面的程式多隻是生成了一個結果，而實際上八皇后可以有很多種可能的佈局。如何才能求得所有結果？其實只要小小地修改一下上面的程式就可以了。

以上面修改過後一維陣列維護棋盤狀態為例。程式在碰到一次row == blen的情況之後就返回了True，然後遞迴一層層地返回True直到最上層。所以找到一個解決方案之後，程式就會退出了。

反過來，如果獲得一個解決方案之後，不判斷EightQueen函式的返回，此時函式會繼續執行col += 1,將狀態搜尋繼續下去，如此收集狀態的任務在row

blen的判斷中，（注意這裡的return可不能刪，這裡需要一個return來提示遞迴的終結條件），而對於每條遞迴路徑總是窮盡所有可能再回頭，這樣就可以獲得到所有可能了：

​
  def EightQueen(board,row):
   blen = len(board)
   if row == blen: # 來到不存在的第九行了
   print board
   return True
   col = 0
   while col < blen:
   if check(board,row,col):
    board[row] = col
    if EightQueen(board,row+1):
    # return True 去掉這裡即可，或者直接刪除掉整個判斷，只留下單一個EightQueen(board,row+1)
    pass
   col += 1
   return False

示例結果：

[0, 4, 7, 5, 2, 6, 1, 3] [0, 5, 7, 2, 6, 3, 1, 4] [0, 6, 3, 5, 7, 1, 4, 2] [0, 6, 4, 7, 1, 3, 5, 2] [1, 3, 5, 7, 2, 0, 6, 4] [1, 4, 6, 0, 2, 7, 5, 3] [1, 4, 6, 3, 0, 7, 5, 2] [1, 5, 0, 6, 3, 7, 2, 4] [1, 5, 7, 2, 0, 3, 6, 4] …… 總共有92種佈局方案

非遞迴

非遞迴解這個問題，很顯然是要去維護一個stack來儲存一個路徑了。簡單來說，這個棧中維護的應該是“尚未嘗試去探索的可能”，當我開始檢查一個特定的位置，如果檢查通過，那麼應該做的是首先將本位置右邊一格加入棧，然後再把下一行的第一個格子加入棧。注意前半個操作很容易被忽視，但是如果不將本位置右邊一格入棧，那麼如果基於本格有皇后的情況進行的遞迴最終沒有返回一個結果的話，接下來就不知道往哪走了。如果使用了棧，那麼用於掃描棋盤的遊標就不用自己在迴圈裡+=1了，迴圈中游標的移動全權交給棧去維護。

程式碼如下：

​
  def EightQueen(board):
   blen = len(board)
   stack = Queue.LifoQueue()
   stack.put((0,0)) # 為了自洽的初始化
   while not stack.empty():
   i,j = stack.get()
   if check(board,i,j): # 當檢查通過
    board[i] = j # 別忘了放Queen
    if i >= blen - 1:
    print board # i到達最後一行表明已經有了結果
    break
    else:
    if j < blen - 1: # 雖然說要把本位置右邊一格入棧，但是如果本位置已經是行末尾，那就沒必要了
     stack.put((i,j+1))
    stack.put((i+1,0)) # 下一行第一個位置入棧，準備開始下一行的掃描
   elif j < blen - 1:
    stack.put((i,j+1)) # 對於未通過檢驗的情況，自然右移一格即可

顯然，把break去掉就是求所有解了

C語言版

​
  #include <stdio.h>
  
  static int board[8] = {};
  int board_size = sizeof(board)/sizeof(int);
  
  int check(int *board,int row){
   int i = 0;
   while(i < row){
   if(board[i] == board[row] || row - i == board[row] - board[i] || row - i == board[i] - board[row]){
    return 0;
    }
   i++;
   }
   // printf("board[%d]: %d\n",row,board[row]);
   return 1;
   }
  
  void print_board(int *board){
   int i;
   int size = board_size;
   for(i=0;i<size;i++){
   printf("%d,",board[i]);
   }
   printf("\n");
   i = 0;
   while (i < size){
   int j;
   for (j=0;j<size;j++){
    if(j == board[i]){
    printf("%s ","■ ");
    }
    else{
    printf("%s ","□ ");
    }
    }
   printf("\n");
   i++;
   }
   }
  
  int eight_queen(int *board,int row){
   if (row == 8){
   print_board(board);
   return 1;
   }
   board[row] = 0;
   while (1){
   if (check(board,row) && eight_queen(board,row+1)){
    return 1;
    }
   else{
    if(++board[row] >= 8){
    break;
    }
    }
   }
  
   return 0; 
   }
  
  int main(){
   eight_queen(board,0);
   // print_board(board);
   return 0;
   }