八皇后问题--递归

问题描述：

         在一个8×8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列或同一对角线上。问共有多少种不同的方法。

 

程序：

1.     public void testEightPrince() {
2.         // grids代表8*8的棋盘，如果值为TRUE，表示可以此位置为空，还可以放置一个皇后
3.         boolean[][] grids = new boolean[8][];
4.         for (int index = 0; index < grids.length; index++) {
5.             grids[index] = new boolean[8];
6.         }
7.         // 初始化，所有的位置都可以放置一个皇后
8.         for (int x = 0; x < grids.length; x++) {
9.             for (int y = 0; y < grids[x].length; y++) {
10.                 grids[x][y] = true;
11.             }
12.         }
13.         int x = 0, y = 0;
14.         for (x = 0; x < 8; x++) {
15.             enableAllPos(grids);
16.             // 把皇后放在x,y处。要做的是把其同一行，同一列或者同一对角线统统置成不能放皇后的棋盘
17.             disablePos(grids, x, y);
18.             // 递归判断此种情况下可以放置的所有可能
19.             canLay(grids, x, y, 1, "");
21.         }
22.     }
24.     // 使棋盘所有的位置都可以放置一个皇后，回到最初始的状态
25.     public void enableAllPos(boolean[][] grids) {
26.         for (int x = 0; x < grids.length; x++) {
27.             for (int y = 0; y < grids[x].length; y++) {
28.                 grids[x][y] = true;
29.             }
30.         }
31.     }
33.     /**
34.      * 把棋盘的x,y点所对应的行，列，对角线上的值置成不能放皇后
35.      * 
36.      * @param grids
37.      * @param x
38.      * @param y
39.      */
40.     public void disablePos(boolean[][] grids, int x, int y) {
41.         // 同一行或者同一列
42.         for (int j = 0; j < 8; j++) {
43.             grids[x][j] = false;
44.             grids[j][y] = false;
45.         }
46.         // 右对角线
47.         int count = 1;
48.         while (x + count <= 7 && y + count <= 7) {
49.             grids[x + count][y + count] = false;
50.             count++;
51.         }
52.         count = 1;
53.         while (x - count >= 0 && y - count >= 0) {
54.             grids[x - count][y - count] = false;
55.             count++;
56.         }
57.         // 左对角线
58.         count = 1;
59.         while (x - count >= 0 && y + count <= 7) {
60.             grids[x - count][y + count] = false;
61.             count++;
62.         }
63.         count = 1;
64.         while (x + count <= 7 && y - count >= 0) {
65.             grids[x + count][y - count] = false;
66.             count++;
67.         }
68.     }
70.     public boolean canLay(final boolean[][] grids, int xPos, int yPos,
71.             int level, String temp) {
73.         if (level == 8) {
74.             boolean result = hasEmptyPos(grids);
75.             if (result) {
76.                 System.out.println(" 节点序列：" + temp + ",(" + xPos + "," + yPos
77.                         + ")");
78.             }
79.             // System.out.println(" level 到达最大：" + hasEmptyPos(grids));
80.             return result;
81.         }
82.         /**
83.          * 保持当前棋盘现场，复制一个棋盘供下一步调用
84.          */
85.         boolean[][] newGrids = new boolean[8][8];
86.         for (int x = 0; x < 8; x++) {
87.             for (int y = 0; y < 8; y++) {
88.                 newGrids[x][y] = grids[x][y];
89.             }
90.         }
91.         disablePos(newGrids, xPos, yPos);
92.         Position[] poses = getEmptyPos(newGrids, xPos);
93.         if (poses == null || poses[0] == null) {
94.             return false;
95.         }
96.         for (int posIndex = 0; posIndex < poses.length; posIndex++) {
97.             if (canLay(newGrids, poses[posIndex].xPos, poses[posIndex].yPos,
98.                     level + 1, temp + "(" + xPos + "," + yPos + "),")) {
99.                 // return true;//当只需找出一种可行解，而不是所有的放置情况，可以把去掉此句的注释,注释掉表示得到所有的解
100.             }
101.         }
102.         return false;
103.     }
105.     private class Position {
106.         int xPos = 0;
107.         int yPos = 0;
108.     }
110.     /**
111.      * 取得当前棋盘的下一个可放皇后位置的点的集合，这个决定了搜索空间的大小， 下面采用了最大减少搜索空间的方法，即下一个可放位置点的结合从上一个可放
112.      * 位置的下一个x方向的位移上取得。保证了算法的效率，如果整个棋盘扫描， 效率很低，而且会出现重复的情况。
113.      * 
114.      * @param grids
115.      *            当前棋盘
116.      * @param prevXpos
117.      *            上一个可放位置的x的坐标
118.      * @return
119.      */
120.     public Position[] getEmptyPos(boolean[][] grids, int prevXpos) {
122.         ArrayList<Position> list = new ArrayList<Position>();
123.         // 下一个x方向的位置
124.         int x = (prevXpos + 1) % 8;
125.         for (int y = 0; y < 8; y++) {
126.             if (grids[x][y]) {
127.                 Position pos = new Position();
128.                 pos.xPos = x;
129.                 pos.yPos = y;
130.                 list.add(pos);
131.             }
132.         }
133.         /*
134.          * for(int x = 0; x < 8; x++){ for(int y = 0; y < 8; y++){
135.          * if(grids[x][y]){ Position pos = new Position(); pos.xPos = x;
136.          * pos.yPos = y; list.add(pos); } } }
137.          */
138.         return list.toArray(new Position[1]);
139.     }
141.     public boolean hasEmptyPos(boolean[][] grids) {
142.         for (int x = 0; x < grids.length; x++) {
143.             for (int y = 0; y < grids[x].length; y++) {
144.                 if (grids[x][y] == true) {
145.                     return true;
146.                 }
147.             }
148.         }
149.         return false;
150.     }