蓝桥杯基础（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();
	}