1 packagealgorithm;2

3 importjava.util.Comparator;4 importjava.util.PriorityQueue;5

6 /**

7 * 重排九宫，或者称之为八码数问题，或是说数字推盘问题4，使用分支界定法实现8 */

9 public classEightPuzzle {10 //方阵边长

11 private static final int N = 3;12

13 //坐标的行列索引向下、左、上、右

14 private static final int[] row = {1, 0, -1, 0};15 private static final int[] col = {0, -1, 0, 1};16

17 /**

18 * 节点19 */

20 private classNode {21 privateNode parent;22 private int[][] mat;23 private intx, y;24 private intcost;25 private intlevel;26 privateNode() {27 mat = new int[N][N];28 }29 }30

31 /**

32 * 用于堆排序的比较对象33 */

34 class Comp implements Comparator{35 @Override36 public intcompare(Node o1, Node o2) {37 return (o1.cost + o1.level) - (o2.cost +o2.level);38 }39 }40

41 /**

42 * 打印矩阵43 *44 *@parammat45 */

46 private void printMatrix(int[][] mat) {47 for (int i = 0; i < N; i++) {48 for (int j = 0; j < N; j++)49 System.out.print(mat[i][j] + " ");50 System.out.println();51 }52 }53

54 /**

55 * 交换二维矩阵中的值56 *57 *@parammat58 *@paramx59 *@paramy60 *@paramnewX61 *@paramnewY62 */

63 private void swap(int[][] mat, int x, int y, int newX, intnewY) {64 int tmp =mat[x][y];65 mat[x][y] =mat[newX][newY];66 mat[newX][newY] =tmp;67 }68

69 /**

70 * 矩阵复制71 *72 *@paramarr173 *@paramarr274 */

75 private static void copyMatrix(int[][] arr1, int[][] arr2) {76 for (int i = 0; i < arr1.length; i++)77 System.arraycopy(arr1[i], 0, arr2[i], 0, arr1[0].length);78

79 }80

81 /**

82 * 分配一个新节点83 *84 *@parammat85 *@paramx86 *@paramy87 *@paramnewX88 *@paramnewY89 *@paramlevel90 *@paramparent91 *@return

92 */

93 private Node newNode(int[][] mat, int x, int y, int newX, int newY, intlevel, Node parent) {94 Node node = newNode();95 node.parent =parent;96

97 copyMatrix(mat, node.mat);98

99 swap(node.mat, x, y, newX, newY);100

101 node.cost =Integer.MAX_VALUE;102 node.level =level;103

104 node.x =newX;105 node.y =newY;106

107 returnnode;108 }109

110 /**

111 * 计算错位方块的数量, 即不在目标位置的非空白块的数量112 *113 *@paraminitial114 *@paramfinals115 *@return

116 */

117 private int calculateCost(int[][] initial, int[][] finals) {118 int count = 0;119 for (int i = 0; i < N; i++)120 for (int j = 0; j < N; j++)121 if (initial[i][j] != 0 && initial[i][j] !=finals[i][j]) {122 count++;123 }124 returncount;125 }126

127 /**

128 * 检查(x，y)是否为有效矩阵坐标129 *130 *@paramx131 *@paramy132 *@return

133 */

134 private boolean isSafe(int x, inty) {135 return (x >= 0 && x < N && y >= 0 && y

138 /**

139 * 打印路径140 *141 *@paramroot142 */

143 private voidprintPath(Node root) {144 if (root == null)145 return;146 printPath(root.parent);147 printMatrix(root.mat);148 System.out.println();149 }150

151 /**

152 * 分支界定法解决问题153 *154 *@paraminitial155 *@paramx156 *@paramy157 *@paramfinals158 */

159 private void solve(int[][] initial, int x, int y, int[][] finals) {160 //创建优先级队列以存储搜索树的活动节点

161 PriorityQueue pq = new PriorityQueue<>(newComp());162

163 //创建一个根节点并计算其成本

164 Node root = newNode(initial, x, y, x, y, 0, null);165 root.cost =calculateCost(initial, finals);166

167 //将根添加到活动节点列表中；

168 pq.add(root);169

170 //查找成本最低的活动节点，171 //将其子级添加到活动节点列表中，并最后将其从列表中删除。

172 while (!pq.isEmpty()) {173 //查找估计成本最低的活动节点, 找到的节点将从活动节点列表中删除

174 Node min =pq.poll();175

176 //如果min是一个答案节点

177 if (min.cost == 0) {178 printPath(min);179 return;180 }181

182 //为每个min节点的孩子183 //一个节点最多4个孩子

184 for (int i = 0; i < 4; i++) {185 if (isSafe(min.x + row[i], min.y +col[i])) {186 //创建一个子节点并计算它的成本

187 Node child =newNode(min.mat, min.x, min.y,188 min.x + row[i], min.y +col[i],189 min.level, min);190 child.cost =calculateCost(child.mat, finals);191

192 //将min的孩子添加到活动节点列表

193 pq.add(child);194 }195 }196 }197 }198

199 public static voidmain(String[] args) {200 int[][] initial =

201 {202 {1, 2, 3},203 {5, 6, 0},204 {7, 8, 4}205 };206

207 int[][] finals =

208 {209 {1, 2, 3},210 {5, 8, 6},211 {0, 7, 4}212 };213

214 //0的位置(空白块)

215 int x = 1, y = 2;216

217 EightPuzzle eightPuzzle = newEightPuzzle();218 eightPuzzle.solve(initial, x, y, finals);219

220 }221 }