算法：数字推盘游戏--重排九宫（8-puzzle）
一、数字推盘游戏
数字推盘游戏（n-puzzle）是一种最早的滑块类游戏，常见的类型有十五数字推盘游戏和八数字推盘游戏等。也有以图画代替数字的推盘游戏。可能Noyes Palmer Chapman在1874年发明十五数字推盘，但Sam Loyd则在1891年也宣称为其发明。
八数字推盘（又名重排九宫）则同样是Noyes Palmer Chapman在1870年代发明，并且马丁·加德纳在科学科普杂志上寻求更快的解答。也有人宣称重排九宫是传统中国游戏，来自洛书，并且为华容道的祖先。
二、分支界定法
给定一个具有 8 个图块的 3×3 板（每个图块都有一个 1 到 8 的数字）和一个空白空间（用 0 代表）。目的是将数字放置在图块上，以使用空白的空间匹配最终配置。我们可以将四个相邻的（左，右，上方和下方）图块滑动到空白区域。
通常可以使用 DFS、BFS 搜索算法来进行暴力破解。本文利用分支界定法，来“智能”的排名函数（近似于成本函数）来加快对成本节点的搜索，这里每一个节点都存有当前移动后整个方块的分布，从而避免在找不到最终答案的子树继续搜索。
分支界定法基本上涉及三种类型的节点：
- 存活节点，是已生成但尚未生成其子节点的节点；
- 当前正在扩展的节点，探索它的子节点；
- 死亡节点，死节点是生成的节点，将不再扩展或探索。死节点的所有子节点均已扩展。
成本函数：C(x) = g(x) + h(x)。
g(x) 是当前节点到根节点的成本（即路径长度）。h(x) 是当前除开空白块外与答案节点错位（放错位置）的成本，假设在往上下左右任一方向移动图块的成本为 1。
给定初始状态和目的状态：
下图显示了上述算法从给定的8-Puzzle初始配置达到最终配置所遵循的路径。注意，仅具有最小成本函数值的节点被扩展。
（注意：以上是本算法的流程图）
三、分支界定法的实现
节点的构造：
1 /** 2 * 节点 3 */ 4 private class Node { 5 private Node parent; 6 private int[][] mat; 7 private int x, y; 8 private int cost; 9 private int level; 10 private Node() { 11 mat = new int[N][N]; 12 } 13 }
插入一个新节点：
1 /** 2 * 分配一个新节点 3 * 4 * @param mat 5 * @param x 6 * @param y 7 * @param newX 8 * @param newY 9 * @param level 10 * @param parent 11 * @return 12 */ 13 private Node newNode(int[][] mat, int x, int y, int newX, int newY, int level, Node parent) { 14 Node node = new Node(); 15 node.parent = parent; 16 17 copyMatrix(mat, node.mat); 18 19 swap(node.mat, x, y, newX, newY); 20 21 node.cost = Integer.MAX_VALUE; 22 node.level = level; 23 24 node.x = newX; 25 node.y = newY; 26 27 return node; 28 }
计算错位成本：
1 /** 2 * 计算错位方块的数量, 即不在目标位置的非空白块的数量 3 * 4 * @param initial 5 * @param finals 6 * @return 7 */ 8 private int calculateCost(int[][] initial, int[][] finals) { 9 int count = 0; 10 for (int i = 0; i < N; i++) 11 for (int j = 0; j < N; j++) 12 if (initial[i][j] != 0 && initial[i][j] != finals[i][j]) { 13 count++; 14 } 15 return count; 16 }
利用优先队列（PriorityQueue）来实现分支界定法：
1 /** 2 * 分支界定法解决问题 3 * 4 * @param initial 5 * @param x 6 * @param y 7 * @param finals 8 */ 9 private void solve(int[][] initial, int x, int y, int[][] finals) { 10 // 创建优先级队列以存储搜索树的活动节点 11 PriorityQueue<Node> pq = new PriorityQueue<>(new Comp()); 12 13 // 创建一个根节点并计算其成本 14 Node root = newNode(initial, x, y, x, y, 0, null); 15 root.cost = calculateCost(initial, finals); 16 17 // 将根添加到活动节点列表中； 18 pq.add(root); 19 20 // 查找成本最低的活动节点， 21 // 将其子级添加到活动节点列表中，并最后将其从列表中删除。 22 while (!pq.isEmpty()) { 23 // 查找估计成本最低的活动节点, 找到的节点将从活动节点列表中删除 24 Node min = pq.poll(); 25 26 // 如果min是一个答案节点 27 if (min.cost == 0) { 28 printPath(min); 29 return; 30 } 31 32 // 为每个min节点的孩子 33 // 一个节点最多4个孩子 34 for (int i = 0; i < 4; i++) { 35 if (isSafe(min.x + row[i], min.y + col[i])) { 36 // 创建一个子节点并计算它的成本 37 Node child = newNode(min.mat, min.x, min.y, 38 min.x + row[i], min.y + col[i], 39 min.level, min); 40 child.cost = calculateCost(child.mat, finals); 41 42 // 将min的孩子添加到活动节点列表 43 pq.add(child); 44 } 45 } 46 } 47 }
分支定界是一种算法设计范例，通常用于解决组合优化问题。 这些问题通常在时间复杂度上呈指数关系（2^N），在最坏的情况下可能需要探索所有可能的排列（扩展完堆中所有可能的节点）。 分支界定相对较快地解决了这些问题。但是在最坏的情况下，我们需要完全计算整个树。充其量，我们只需要完全计算一条穿过树的路径，然后修剪其余路径即可。
本文源代码：
1 package algorithm; 2 3 import java.util.Comparator; 4 import java.util.PriorityQueue; 5 6 /** 7 * 重排九宫，或者称之为八码数问题，或是说数字推盘问题4，使用分支界定法实现 8 */ 9 public class EightPuzzle { 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 class Node { 21 private Node parent; 22 private int[][] mat; 23 private int x, y; 24 private int cost; 25 private int level; 26 private Node() { 27 mat = new int[N][N]; 28 } 29 } 30 31 /** 32 * 用于堆排序的比较对象 33 */ 34 class Comp implements Comparator<Node> { 35 @Override 36 public int compare(Node o1, Node o2) { 37 return (o1.cost + o1.level) - (o2.cost + o2.level); 38 } 39 } 40 41 /** 42 * 打印矩阵 43 * 44 * @param mat 45 */ 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 * @param mat 58 * @param x 59 * @param y 60 * @param newX 61 * @param newY 62 */ 63 private void swap(int[][] mat, int x, int y, int newX, int newY) { 64 int tmp = mat[x][y]; 65 mat[x][y] = mat[newX][newY]; 66 mat[newX][newY] = tmp; 67 } 68 69 /** 70 * 矩阵复制 71 * 72 * @param arr1 73 * @param arr2 74 */ 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 * @param mat 85 * @param x 86 * @param y 87 * @param newX 88 * @param newY 89 * @param level 90 * @param parent 91 * @return 92 */ 93 private Node newNode(int[][] mat, int x, int y, int newX, int newY, int level, Node parent) { 94 Node node = new Node(); 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 return node; 108 } 109 110 /** 111 * 计算错位方块的数量, 即不在目标位置的非空白块的数量 112 * 113 * @param initial 114 * @param finals 115 * @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 return count; 125 } 126 127 /** 128 * 检查（x，y）是否为有效矩阵坐标 129 * 130 * @param x 131 * @param y 132 * @return 133 */ 134 private boolean isSafe(int x, int y) { 135 return (x >= 0 && x < N && y >= 0 && y < N); 136 } 137 138 /** 139 * 打印路径 140 * 141 * @param root 142 */ 143 private void printPath(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 * @param initial 155 * @param x 156 * @param y 157 * @param finals 158 */ 159 private void solve(int[][] initial, int x, int y, int[][] finals) { 160 // 创建优先级队列以存储搜索树的活动节点 161 PriorityQueue<Node> pq = new PriorityQueue<>(new Comp()); 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 void main(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 = new EightPuzzle(); 218 eightPuzzle.solve(initial, x, y, finals); 219 220 } 221 }
