HDU-4531 吉哥系列故事——乾坤大挪移 模拟

题意：给定一个九宫格，然后能够选择某行或者是某列滚动，每个小方格分为上下左右四个块，每个块可以涂上4种不同的颜色。问最少使用多少步能够使得所有相同颜色相互联通。

分析：由于九宫格的所有的状态只有9！（362880）种，于是想起了先对每个格子进行标号，然后根据逆序对的数量进行一个递增进制数的hash处理，这样bfs搜索就能够去重了，接着只需要判断每个状态是否满足联通即可。这里的判定选择了先统计了不同颜色格子的数量然后dfs搜索，应该并查集也可以搞。滚动使用指针滚动即可，对于不能动的格子该格子所在行和列都不能够滚动。

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;

// 9! = 362880
const int LIM = ;
int fac[]; // 递增进制数的权值
int tot[]; // 四种颜色的个数
char vis[LIM]; // hash九宫格
char op[]; // 滚动的操作的限制
char hav[]; // 4*9个格子的标记 

struct Block {
    char color[];
    int id;
}bk[][];

struct Node {
    Block *ptr[][];
    int key;
    int ti;
    Node() {}
    Node(Block (*x)[]) {
        ti = ;
        for (int i = ; i < ; ++i) {
            for (int j = ; j < ; ++j) {
                ptr[i][j] = &x[i][j];
            }
        }
        getkey();
    }
    void show() {
        for (int i = ; i < ; ++i) {
            for (int j = ; j < ; ++j) {
                printf("%5d", ptr[i][j]->id);
            }
            puts("");
        }
        puts("");
    }
    void getkey() {
        int cnt;
        key = ;
        for (int i = ; i < ; ++i) {
            cnt = ;
            for (int j = i+; j < ; ++j) {
                if (ptr[j/][j%]->id < ptr[i/][i%]->id) ++cnt;
            }
            key += cnt * fac[-i];
        }
    }
    int dfs(int x, int y, int z) {
        if (hav[(x*+y)*+z]) return ;
        hav[(x*+y)*+z] = ;
        char ch = ptr[x][y]->color[z];
        int ret = ;
        if (z == ) {
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (x >  && ptr[x-][y]->color[] == ch) ret += dfs(x-, y, );
        } else if (z == ) {
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (x <  && ptr[x+][y]->color[] == ch) ret += dfs(x+, y, );
        } else if (z == ) {
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (y >  && ptr[x][y-]->color[] == ch) ret += dfs(x, y-, );
        } else {
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (ptr[x][y]->color[] == ch) ret += dfs(x, y, );
            if (y <  && ptr[x][y+]->color[] == ch) ret += dfs(x, y+, );
        }
        return ret;
    }
    bool judge() {
        memset(hav, , sizeof (hav));
        for (int i = ; i < ; ++i) {
            for (int j = ; j < ; ++j) {
                for (int k = ; k < ; ++k) {
                    if (!hav[(i*+j)*+k]) {
                        int cnt = dfs(i, j, k);
                        switch(ptr[i][j]->color[k]) {
                            case 'R': if (cnt != tot[]) return false; break;
                            case 'G': if (cnt != tot[]) return false; break;
                            case 'B': if (cnt != tot[]) return false; break;
                            default : if (cnt != tot[]) return false;
                        }
                    }
                }
            }
        }
        return true;
    }
};

void pre() {
    fac[] = ;
    for (int i = ; i < ; ++i) {
        fac[i] = fac[i-] * i;
    }
}

void swapr(Block *x[], Block *y[], int dir) { // 横向的滚动
    if (dir == ) { // 向左
        y[] = x[], y[] = x[], y[] = x[];
    } else { // 向右
        y[] = x[], y[] = x[], y[] = x[];
    }
}

void swapc(Block *x[], Block *y[], int dir) { // 纵向的滚动
    if (dir == ) { // 向上
        y[] = x[], y[] = x[], y[] = x[];
    } else { // 向下
        y[] = x[], y[] = x[], y[] = x[];
    }
}

int bfs() {
    queue<Node>q;
    Node tmp = Node(bk);
    Node pos;
    memset(vis, , sizeof (vis));
    q.push(tmp); // 初始化是没有逆序对的
    vis[tmp.key] = ;
    while (!q.empty()) {
        pos = q.front();
        q.pop();
        if (pos.judge()) {
            return pos.ti;
        }
        for (int i = ; i < ; ++i) {
            if (op[i]) continue;
            tmp = pos;
            if (i < ) { // 横向的滚动
                for (int j = ; j < ; ++j) {
                    swapr(&pos.ptr[i][], &tmp.ptr[i][], j);
                    tmp.getkey();
                    tmp.ti = pos.ti + ;
                    if (!vis[tmp.key]) {
                        vis[tmp.key] = ;
                        q.push(tmp);
                    }
                }
            } else { // 纵向的
                for (int j = ; j < ; ++j) {
                    swapc(&pos.ptr[][i%], &tmp.ptr[][i%], j);
                    tmp.getkey();
                    tmp.ti = pos.ti + ;
                    if (!vis[tmp.key]) {
                        vis[tmp.key] = ;
                        q.push(tmp);
                    }
                }
            }
        }
    }
}

int main() {
    int T, ca = ;
    pre();
    scanf("%d", &T);
    while (T--) {
        memset(op, , sizeof (op));
        memset(tot, , sizeof (tot));
        for (int i = ; i < ; ++i) {
            for (int j = ; j < ; ++j) {
                scanf("%s", bk[i][j].color);
                for (int k = ; k < ; ++k) {
                    switch(bk[i][j].color[k]) {
                        case 'R': ++tot[]; break;
                        case 'G': ++tot[]; break;
                        case 'B': ++tot[]; break;
                        default : ++tot[];
                    }
                }
                bk[i][j].id = i*+j; // 0-8
                if (bk[i][j].color[] == '') {
                    op[i] = op[+j] = ; // 两种操作无法进行
                }
            }
        }
        printf("Case #%d: %d\n", ++ca, bfs());
    }
    return ;
}