中国象棋程序的设计与实现(六)--N皇后问题的算法设计与实现(源码+注释+截图)

八皇后问题，是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种方法可以解决此问题。

2010年，在写完中国象棋的核心模块后，当时添加了一个扩展应用模块，N皇后问题。

效果图









算法源码

下面是控制台程序的源码。

/**
* 项目名称: FansChineseChess
* 版本号：2.0
* 名字：雷文
* 博客: http://FansUnion.cn * CSDN:http://blog.csdn.net/FansUnion
* 邮箱: leiwen@FansUnion.cn
* QQ：240-370-818
* 版权所有: 2011-2013,leiwen
*/
package cn.fansunion.chinesechess.ext.empress;

import java.awt.Point;
import java.util.ArrayList;
import java.util.List;

/**
* 求N皇后的所有合法布局
*
* 3个约束条件：任何2个棋子都不能占居棋盘上的同一行、或者同一列、或者同一对角线。
*
* 棋盘状态的变化情况，可以看作一个N叉树。
*
* 求所有合法布局的过程，即为在3个约束条件下先根遍历状态树的过程。
*
* 遍历中访问结点的操作为，判断棋谱上是否已经得到一个完整的布局，如果是，则输出该布局；
*
* 否则依次先根遍历满足约束条件的各棵子树，即首先判断该子树根的布局是否合法，若合法，则
*
* 先根遍历该子树，否则减去该子树分支。
*
* @author leiwen@fansunion.cn,http://FansUnion.cn,
*         http://blog.csdn.net/FansUnion * @since 2.0
*/
public class EmpressModel {

/**
* 皇后的个数
*/
private int num;
/**
* 棋盘数据结构
*/
private int[][] array;
/**
* 棋盘中的布局集合，每一种布局采用简写形式
*/
private List<ArrayList<Point>> lists = new ArrayList<ArrayList<Point>>();
/**
* 棋盘中的布局集合，每一种布局采用完整形式
*/
private List<int[][]> advancedLists = new ArrayList

public EmpressModel(int n) {
this.num = n;
array = new int[n + 1][n + 1];// 默认为0
}

// 初始化所有的布局
public void initAllLayout() {
trial(1);
sort();
initAdvancedLists();
}

/**
* 进入本函数时，在n*n棋盘前j-1列已经放置了满足3个条件的j-1个棋子
*
* 现在从第j列起，继续为后续棋子选择合适的位置
*
* 选择列优先，是为了保证在GUI显示布局的变化，看起来是，每一行的棋子都是从左向右移动的。
*
* 行优先时，每列棋子，从上向下移动。
*
* @param j
*/
private void trial(int j) {
// 进入本函数时，在n*n棋盘前j-1列已经放置了满足3个条件的j-1个棋子
// 现在从第i行起，继续为后续棋子选择合适的位置
if (j > num) {
// 求得一个合法布局，保存起来
saveCurrentLayout();
} else {
for (int i = 1; i <= num; i++) {
// 在第i行第j列放置一个棋子
array[i][j] = 1;
if (isLegal(i, j)) {
trial(j + 1);
}
// 移走第i行第j列的棋子
array[i][j] = 0;
}
}
}

/**
* 判断当前布局是否合法
*
* @return
*/
private boolean isLegal(int row, int col) {

for (int i = 1; i < array.length; i++) {
int sumI = 0;// 第i行之和
int sumJ = 0;// 第i列之和
for (int j = 1; j < array[i].length; j++) {
sumI += array[i][j];
sumJ += array[j][i];
}
if (sumI >= 2 || sumJ >= 2) {
return false;
}
sumI = 0;
sumJ = 0;

}

// 左上到右下的对角线是否有棋子
int i = row - 1;
for (int j = col - 1; j >= 1; j--) {
if (i >= 1 && array[i][j] == 1) {
return false;
}
i--;
}

// 左下到右上的对角线是否有棋子
i = row + 1;
for (int j = col - 1; j >= 1; j--) {
if (i <= this.num && array[i][j] == 1) {
return false;
}
i++;
}

return true;
}

/**
* 保存当前的布局
*/
private void saveCurrentLayout() {
ArrayList<Point> list = new ArrayList<Point>();
for (int i = 1; i < array.length; i++) {
for (int j = 1; j < array[i].length; j++) {
if (array[i][j] == 1) {
list.add(new Point(i, j));
}
}
}
lists.add(list);
}

/**
* 打印所有的布局（最简形式）
*/
public void printBasicLayout() {
int size = lists.size();
for (int i = 0; i < size; i++) {
ArrayList<Point> arrayList = lists.get(i);
int size2 = arrayList.size();
System.out.println("第" + i + "种布局！");
for (int j = 0; j < size2; j++) {
Point point = arrayList.get(j);
System.out.print("(" + (int) point.getX() + ","
+ (int) point.getY() + ")\t");
}
System.out.println();
}
System.out.println();
}

/**
* 打印所有的布局（高级形式）
*/
public void printAddvancedLayout() {
int size = advancedLists.size();
for (int i = 0; i < size; i++) {
int[][] arr = advancedLists.get(i);
System.out.println("第" + i + "种布局！");
for (int j = 1; j <= num; j++) {
for (int k = 1; k <= num; k++) {
System.out.print(arr[j][k] + "\t");
}
System.out.println();
}
System.out.println();
}
System.out.println();
}

/**
* 排序是为了，减少抖动，即每次变换布局时，近可能少地换棋子 （每次切换到下一个布局时，棋子的变换尽可能少，视觉上棋子在有规律的移动）
*/
public void sort() {
sortEveryList();
}

private void sortEveryList() {
/*
* System.out.println("冒泡排序之前："); printAllLayout();
*/
int size = lists.size();
// 对lists中的每个链表，按照点的纵坐标排序
for (int q = 0; q < size; q++) {

ArrayList<Point> arraylist = lists.get(q);

int size2 = arraylist.size();
// 冒泡排序
for (int r = 1; r < size2; r++) {
// 纵坐标从小到大
for (int s = 0; s < size2 - r; s++) {
Point first = arraylist.get(s);
double m = first.getY();

Point second = arraylist.get(s + 1);
double n = second.getY();

if (m > n) {
arraylist.set(s + 1, first);
arraylist.set(s, second);
}

}
}
}

}

private void initAdvancedLists() {
int size = lists.size();
for (int index = 0; index < size; index++) {
ArrayList<Point> list = lists.get(index);
int[][] arr = new int[num + 1][num + 1];

int len = list.size();
for (int i = 0; i < len; i++) {
int x = (int) list.get(i).getY();
int y = (int) list.get(i).getX();
arr[x][y] = 1;
}

advancedLists.add(arr);
}
}

public int[][] getArray() {
return array;
}

public int getNum() {
return num;
}

public List<ArrayList<Point>> getLists() {
return lists;
}

public List<int[][]> getAdvancedLists() {
return advancedLists;
}

public static void main(String[] args) {
EmpressModel em4 = new EmpressModel(4);
em4.initAllLayout();
em4.printBasicLayout();
// 初始化高级保存需要的布局
//em4.initAdvancedLists();
em4.printAddvancedLayout();

}

}

设计思想

算法(模型)和界面相分离。

算法构造数据，界面展示数据。

展示分2种：中国象棋棋盘中和控制台中。

源码出处

本算法源码摘自 http://blog.csdn.net/fansunion/article/details/11787413

中国象棋程序-源码，扩展应用模块--N皇后

原文参见：http://FansUnion.cn/articles/2684