藍橋杯基礎（Java）--2n皇后

一、n皇后問題

n 皇后問題研究的是如何將 n 個皇后放置在 n×n 的棋盤上，並且使皇后彼此之間不能相互攻擊。（不相互攻擊即不能放在相同行，相同列，或對角線上）

class GFG  
{ 
static int N = 4; 
  
/* 用於判斷次對角線是否有皇后 ，row-col是一個常數，但是爲了防止數組出現負索引，所以加上（N-1）。即i-col+n-1。*/
static int []ld = new int[30];  
/* rd 是一個數組，它的索引表示的是 row+col 
這個數組是用來判斷有主對角線上是否有皇后。*/
static int []rd = new int[30]; 
  
/*column array where its indices indicates column and  
used to check whether a queen can be placed in that 
    row or not*/
static int []cl = new int[30]; 
  
/* A utility function to print solution */
static void printSolution(int board[][]) 
{ 
    for (int i = 0; i < N; i++) 
    { 
        for (int j = 0; j < N; j++) 
            System.out.printf(" %d ", board[i][j]); 
        System.out.printf("\n"); 
    } 
} 
  
/* A recursive utility function to solve N 
Queen problem */
static boolean solveNQUtil(int board[][], int col) 
{ 
    /* 如果所有皇后都被放置。 */
    if (col >= N) 
        return true; 
  
    /* 在這一列中，試着把皇后放在各行 */
    for (int i = 0; i < N; i++) 
    { 
          
        /* 檢查皇后是否可以放在board[i][col] */
        /* 檢查可不可以放在board[row][col].
        我們只需要檢查所在的行有沒有已經放皇后（cl[i])
        所在的正對角線（rd[row+col]）是否已經放皇后
        和次對角線（ld[row-col+n-1]）是否已經放皇后。
        */
        if ((ld[i - col + N - 1] != 1 && 
             rd[i + col] != 1) && cl[i] != 1) 
        { 
            /* 可以把皇后放在 board[i][col] */
            board[i][col] = 1; 
            ld[i - col + N - 1] = 
            rd[i + col] = cl[i] = 1; 
  
            /* 遞歸着放接下去的皇后 */
            if (solveNQUtil(board, col + 1)) 
                return true; 
  
            /* 如果把皇后放在board[i][col] 不能解決問題，
            那我們就把皇后從這個位置擦去，
            重新安排這個皇后的位置。這就是回溯。
             */
            board[i][col] = 0; // BACKTRACK 
            ld[i - col + N - 1] = 
            rd[i + col] = cl[i] = 0; 
        } 
    } 
  
    /* 如果在這一列任何行都不能放皇后。 */
    return false; 
} 

二、2n皇后問題

這道題目是N皇后問題的變形，增加了兩個限制條件:

• 設置棋盤爲0的位置無法放置皇后
• 有黑皇后和白皇后兩種

每個皇后用三個數組分別保存N列的情況，$2N-1$條正斜線，$2N-1$條反斜線的皇后情況，判斷是否能放皇后即可。區別是這裏用到兩層循環，分別放黑皇后和白皇后。當然回溯結束還要恢復到初始情況進行下一行的回溯.

import java.util.Scanner;

public class Main {
	private static final int MAX_N = 8;
	private Scanner sc;
	private int n;	// 棋盤大小
	private int[][] board;	// 棋盤情況，1可以放皇后，0不能放皇后
	// 每列的皇后情況，true有，false沒有，下標從0開始
	private boolean[] columnBlack;
	private boolean[] columnWhite;
	// 正斜線的皇后情況，true有，false沒有，下標從0開始
	private boolean[] slashBlack;
	private boolean[] slashWhite;
	// 反斜線的皇后情況，true有，false沒有，下標從1開始
	private boolean[] backSlashBlack;
	private boolean[] backSlashWhite;
	private int solution;	// 放法的數量

	public Main() {
		init();	// 初始化
		sc = new Scanner(System.in);
		while (sc.hasNext()) {
			input();		// 輸入棋盤情況
			solution = 0;	// 初始0种放法
			backTrack(0);	// 回溯，第0行開始
			System.out.println(solution);
		}
		sc.close();
	}

	private void init() {
		board = new int[MAX_N][MAX_N];			// 棋盤
		columnBlack = new boolean[MAX_N];		// 列
		columnWhite = new boolean[MAX_N];
		slashBlack = new boolean[2 * MAX_N - 1];// 斜線
		slashWhite = new boolean[2 * MAX_N - 1];
		backSlashBlack = new boolean[2 * MAX_N];// 反斜線
		backSlashWhite = new boolean[2 * MAX_N];
	}

	private void input() {
		n = sc.nextInt();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				board[i][j] = sc.nextInt();
			}
		}
	}

	private void backTrack(int row) {
		if (row >= n) {	// 回溯結束條件
			solution++;
			return;
		}
		for (int i = 0; i < n; i++) {	// 在第i列上放黑皇后
			if (0 == board[row][i]) {	// row行i列是否能放皇后
				continue;				// 0，不能放
			}
			if (columnBlack[i]) {		// i列上是否有黑皇后
				continue;				// 有，不能放
			}
			// 正反斜線上是否有皇后
			if (slashBlack[row + i] || backSlashBlack[n - row + i]) {
				continue;	// 有，不能放
			}
			// 可以放黑皇后
			columnBlack[i] = true;
			slashBlack[row + i] = true;
			backSlashBlack[n - row + i] = true;
			for (int j = 0; j < n; j++) {	// j列上放白皇后
				if (j == i || 0 == board[row][j]) {// 有黑皇后或者不能放皇后
					continue;
				}
				if (columnWhite[j]) {	// 第j列是否有白皇后
					continue;			// 有，不能放
				}
				// 正反斜線是否有白皇后
				if (slashWhite[row + j] || backSlashWhite[n - row + j]) {
					continue;	// 有不能放
				}
				// 可以放白皇后
				columnWhite[j] = true;
				slashWhite[row + j] = true;
				backSlashWhite[n - row + j] = true;
				// 回溯下一行
				backTrack(row + 1);
				// 下層回溯結束，恢復白皇后情況
				columnWhite[j] = false;
				slashWhite[row + j] = false;
				backSlashWhite[n - row + j] = false;
			}
			// 下層回溯結束，恢復黑皇后情況
			columnBlack[i] = false;
			slashBlack[row + i] = false;
			backSlashBlack[n - row + i] = false;
		}
	}

	public static void main(String[] args) {
		new Main();
	}