紫书 第7章 暴力求解法 习题7-9 Cubic Eight-Puzzle UVA - 1604

https://onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4479

https://vjudge.net/problem/UVA-1604

这题是经典的八数码问题(eight puzzle problem的立体版。
八数码问题的状态并不多，用BFS就可以直接解决。现在每个面上从一个数字换成了一个方块，整个问题的状态多了很多。这个问题我从BFS开始尝试，用了几种不同的解法来解决，下边是我详细的解题记录。

题目大意

在一个3x3的网格中放有8个正方形，每个正方形6个面被染成了红色，白色和蓝色。前后/上下/左右的颜色一致。开始的时候所有正方形的上下是白色，前后是红色，左右是蓝色。

给定最后整个网格顶面的颜色以及空格的位置。输出最小能解出这个问题的步数。如果超过了30步，就算作无解，输出-1。

题目分析

对于这种问题，刚开始就能很好地估计总共会有多少种状态，根据这个再来选择相应的算法会更加有效。
因为整个网格里有9个格子，每个格子里边总共的状态 = 正方形可能的状态 + 1 (空格）
而正方形虽然只有3种颜色，但是我们还得考虑方向。当白色在顶面的时候，有可能前边是蓝色或者红色。这样说来，一个正方形最多可能有六种状态。 我们用顶面和前面来标记正方形：就可以得到所有的状态：
【白红，白蓝，红白，红蓝，蓝白，蓝红】

由此可知，每个正方形最多有7种状态。
这整个图所有的状态就等于 7^9 = 40353607 ~= 4e7种状态。

基础算法：广度优先 BFS （TLE）

应该要求是找最短路径，最先想到的算法很自然就是BFS。 不过在写之前还是应该算算BFS能不能足够快地跑完。

BFS的速度分析

如果我们写BFS的话，每种状态最多访问一次，这个数字对于这个算法来说大体上还是能接受的。不过考虑到每次BFS的时候还需要把原来的状态扩展回grid，这个操作需要3X3的循环，总共是9次操作。然后又需要循环4个方向，如果找到下个状态，需要把grid再次折叠，这样又会消耗9次操作。所以每种状态都需要扩展和折叠一次，总共18次操作。

算上之前的状态，总共要进行大概4e7 * 18 = 7.2e8次操作，这个速度的算法肯定会超时了。

代码

抱着严谨的态度，我还是把BFS的代码写出来了，代码如下

#include <bits/stdc++.h>

using namespace std;

// Roll to: Right, Left, Front, Back.
const int DR [] = {0, 0, 1, -1};
const int DC [] = {1, -1, 0, 0};
const string ColorSt [] = {"WR", "WB", "RW", "RB", "BW", "BR", "E"}; 
const int EMPTY = 6;
const int StMap [][4] = {
  {5, 5, 2, 2}, // WR : BR BR RW RW
  {3, 3, 4, 4}, // WB : RB RB BW BW
  {4, 4, 0, 0}, // RW : BW BW WR WR
  {1, 1, 5, 5}, // RB : WB WB BR BR
  {2, 2, 1, 1}, // BW : RW RW WB WB
  {0, 0, 3, 3}, // BR : WR WR RB RB
};
int cnt = 0;
char endCharGrid[3][3];
int grid[3][3];
// Encode 3 bits per St. 0 - 5: square states, 6: Empty
// 0: not visited, -1: end state, others: depth 
int ids[(1 << (3 * 9)) + 5];

int ID() {
    int st = 0;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            int offset = 1 << ((i * 3 + j) * 3);
            st += offset * grid[i][j];
        }
    }
    return st;
}

void bt(int i, int j) {
    if (i == 3) { ids[ID()] = -1; return; }
    
    char c = endCharGrid[i][j];
    int st = 0, ed = 0;
    if (c == 'W') st = 0, ed = 2;
    if (c == 'R') st = 2, ed = 4;
    if (c == 'B') st = 4, ed = 6;
    if (c == 'E') st = 6, ed = 7;
    
    for (int k = st; k < ed; k++) {
        grid[i][j] = k;
        int ni = i, nj = j + 1;
        if (nj == 3) nj = 0, ni++;
        bt(ni, nj);
    }
}

void fillGrid(int &x, int &y, int id) {
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            int val = (id >> ((i * 3 + j) * 3)) % 8;
            if (val == EMPTY) x = i, y = j;
            grid[i][j] = val;
        }
}

int bfs() {
    queue<int> q;
    int start = ID();
    if (ids[start] == -1) return 0; 
    ids[start] = 1;
    q.push(start);
    while(!q.empty()) {
        int id = q.front(), d = ids[id], x, y; q.pop();
        fillGrid(x, y, id);
        for (int i = 0; i < 4; i++) {
            int nx = DR[i] + x;
            int ny = DC[i] + y;
            if (nx < 0 || ny < 0 || nx > 2 || ny > 2) continue;
            int cur = grid[nx][ny];
            int nxt = StMap[cur][i];
            // Simulate the block move
            assert(grid[x][y] == EMPTY);
            grid[x][y] = nxt;
            grid[nx][ny] = EMPTY;
            int nid = ID();
            if (ids[nid] == -1) return d; // found
            if (!ids[nid] && d < 30) {
                ids[nid] = d + 1;
                q.push(nid);    
            }
            // backtrack
            grid[x][y] = EMPTY;
            grid[nx][ny] = cur;
        }
    }
    return -1;
}

int main() {
    int x, y;
    while (cin >> y >> x && x && y) {
        memset(ids, 0, sizeof(ids));
        for (int i = 0; i < 3; i++) 
            for (int j = 0; j < 3; j++) 
                cin >> endCharGrid[i][j];
        // Use grid to expand the end state first.
        bt(0, 0);
        // Now reset to the start state.
        memset(grid, 0, sizeof(grid));
        grid[x - 1][y - 1] = EMPTY;
        cout << bfs() << endl;
    }
    return 0;
}

这里大概解释下我的做法：
首先我把整个grid的状态折叠成一个ID，每3个bits表示一个格子。然后把结果的状态扩展开，然后直接把结果的状态写到ids那个数列里（值为-1）。那个数列用来存储扩展的深度。如果找到了-1， 当前深度就是找到的深度。

运行结果

当然，这个算法肯定是不负众望的超时了。题目给的限时是3s，这个算法光例题跑了4.5s。

优化算法1：双向广度优先遍历 Bidirectional BFS

对于BFS我们每次往下扩展一层，现有的queue里的状态就会成指数级别增长。有一种可行的做法就是从起始状态和最终状态同时开始BFS，这样如果两个状态在中途相遇，那么结果就等于这两个状态之和。 因为这道题限制深度最多为30，如果我们两个方向一起做的话，深度限制就会减半到15，这样扩展的状态会大大减少。

代码

双向广度优先的代码和BFS的代码基本上没太大差别。唯独不一样的就是需要把结束状态的ID先存下来，然后放到BFS的队列里。之后正向用正数，反向用负数。如果找到ids数列里边的值和现在的符号不一样，那么就返回abs(curId - ids[nid] - 1还要记得把深度范围从 <30改成 -15 < d < 16。为了省篇幅，代码我就不贴了。

运行结果

改成双向广度优先遍历之后，例题的运算速度提高到了1.47s。比BFS快了三倍。我抱着试一试的态度提交了这份代码，然而还是让我有点失望的超时了。

优化

当我开始写IDA*的时候才发现这个算法慢的原因是我的binary state太大了。因为我用了(1 << (3 * 9)) + 5 = 134217733 那么大的数列来存储状态，这个数列光重设就要很久的时间。当我尝试着把状态缩减到7^8*10的大小以后，这个算法就可以通过了。状态的压缩和解压用了下边的函数，总共大小缩减到了57648010 + 5，大概只是原来的1/3那么大。

int ID() {
    int st = 0, mul = 1, x, y;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (grid[i][j] == EMPTY) x = i, y = j;
            else {
                st += mul * (grid[i][j] + 1);
                mul *= 7;
                
            }
        }
    }
    st += mul*(x*3 + y + 1);
    return st;
}

void fillGrid(int &x, int &y, int id) {
    int xy = (id / 5764801) - 1;
    x = xy / 3, y = xy % 3;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if (x == i && y == j) grid[i][j] = EMPTY;
            else {
                int val = id % 7 - 1;
                grid[i][j] = val;
                id /= 7;
            }
        }
    assert(id == xy + 1);
}

优化算法2：IDA*

A* 算法用来做路径搜索是非常有效的。不过因为A* 属于贪心算法，在暴力求解这章里我们用IDA*来求解。算法的精髓是要定义一个合理的乐观估价方程（heuristic function）来有效的提前剪枝，这样整个算法可以比BFS少跑很多不必要的状态。 比如这道题，我们知道我们一定要每一个方块的最终顶面都要和给定的顶面相符，那不相符的顶面数量就是一个很好的估价方程。我们还可以找现在的空位到每个不相符顶面的最大距离（因为我们必须要跑到那个格子去把顶面改对）来提升估价的准确性。（实现请看下边的代码）

IDA虽然需要对深度进行循环，但是因为小的深度跑的状态少，所以速度损失是很小的。

写IDA的时候都不用把之前的状态存下来，只需要把上次的状态跳过就可以了。加上IDA*里的循环是类似于dfs的回溯递归，因此整个代码比起之前的简洁了很多。

下边直接贴我的代码：

#include <bits/stdc++.h>

using namespace std;

// Roll to: Right, Left, Front, Back.
const int DR [] = {0, 0, 1, -1};
const int DC [] = {1, -1, 0, 0};
const string ColorSt [] = {"WR", "WB", "RW", "RB", "BW", "BR", "E"}; 
const int EMPTY = 6;
const int StMap [][4] = {
  {5, 5, 2, 2}, // WR : BR BR RW RW
  {3, 3, 4, 4}, // WB : RB RB BW BW
  {4, 4, 0, 0}, // RW : BW BW WR WR
  {1, 1, 5, 5}, // RB : WB WB BR BR
  {2, 2, 1, 1}, // BW : RW RW WB WB
  {0, 0, 3, 3}, // BR : WR WR RB RB
};
char endCharGrid[3][3];
int grid[3][3], ex, ey;

int h(int x, int y) {
    int diff = 0, dis = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if(ColorSt[grid[i][j]][0] != endCharGrid[i][j]) {
                diff++;   
                dis = max(dis, abs(x - i) + abs(y - j));
            }
        }
    return max(diff, dis);
}

bool bt(int d, int maxd, int x, int y, int px, int py) {
    int hv = h(x, y);
    if (hv == 0) return true; 
    if (d + hv - 1 > maxd) return false;
    for (int i = 0; i < 4; i++) {
        int nx = DR[i] + x;
        int ny = DC[i] + y;
        if (nx < 0 || ny < 0 || nx > 2 || ny > 2 || (nx == px && ny == py)) continue;
        int cur = grid[nx][ny];
        int nxt = StMap[cur][i];
        grid[x][y] = nxt;
        grid[nx][ny] = EMPTY;
        if(bt(d + 1, maxd, nx, ny, x ,y)) return true;
        // backtrack
        grid[x][y] = EMPTY;
        grid[nx][ny] = cur;
    }
    return false;
}

int main() {
    int x, y;
    while (cin >> y >> x && x && y) {
        for (int i = 0; i < 3; i++) 
            for (int j = 0; j < 3; j++)  {
                cin >> endCharGrid[i][j];
                if (endCharGrid[i][j] == 'E') ex = i, ey = j;
            }
        // Now reset to the start state
        bool found = false;
        for (int maxd = 0; maxd <= 30; maxd++) {
            memset(grid, 0, sizeof(grid));
            grid[x - 1][y - 1] = EMPTY;
            if (bt(0, maxd, x - 1, y - 1, -1, -1)) {
                cout << maxd << endl;
                found = true;
                break;
            }
        }
        if (!found) cout << -1 << endl;
    }
    return 0;
}

这个代码虽然过了，但可能我优化的并不是很好，速度并不是很快，甚至还没有用双向BFS快。

小结

这道题给我的提示：BFS不够快的时候，我们能想到几种可行的解决方法。
1）想办法跟有效的折叠状态，以减少用来存储状态的空间，这样也是可以给程序提速的。
2）在结束状态能够很清楚的推出的前提下，可以使用双向BFS来提速。
3）A类算法是这类题的杀手锏。只要能找到有效的乐观估价方程，可以直接考虑用A或者IDA*来求解。