【ACM】魔方十一题

0. 前言
打了两年的百度之星，都没进决赛。我最大的感受就是还是太弱，总结起来就是：人弱就要多做题，人傻就要多做题。
题目还是按照分类做可能效果比较好，因此，就有了做几个系列的计划。这是系列中的第一个，解决OJ中有关魔方的问题。

1. 概述
魔方大概会涉及两类算法：搜索和模拟。这里的搜索方式一般是双广或者bfs+剪枝，因为双广基本上就可以把题目都解了，所以我也没去
考虑A*。我自身不会玩儿魔方，因此剪枝策略也就两种，不过效果还是很好的。模拟就相对简单，仅需要了解几种旋转的方式基本上是可解。
搜索过程中存在状态爆照问题，因为对于同一个魔方从不同的角度观察得到的抽象数据类型可能不尽相同，但是状态却等价。因此，
很多题需要找到所有可能等价的状态，这其实也是一堆排列。

写魔方旋转以及等价状态，我没有什么特别好的办法。不过由给定的顺时针，可以得到相应的逆时针；由正立状态及倒立状态的映射关系，可以
仅仅通过描述正立排列迅速得到倒立状态。

魔方问题的关键就在于剪枝，双广别写萎了，以及状态等价。

2. 题目
2.1 HDOJ 4801
这是一道2阶魔方，前面做过题解，请参考【HDOJ】4801 Pocket Cube 的几种解法和优化。

2.2 HDOJ 5292
题目大意是给定任何的2阶魔方，需要判定该魔方能否复原。因为这个题目的case范围是$10^4$，所以直接在网上找的结论。具体缘由不清楚。

/* 5292 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

int a[11][11]={
    0,0,0,0,1,0,-1,0,0,0,0,
    0,0,0,0,-1,0,1,0,0,0,0,
    -1,0,1,0,0,0,0,0,-1,0,1,
    1,0,-1,0,0,0,0,0,1,0,-1,
    0,0,0,0,1,0,-1,0,0,0,0,
    0,0,0,0,-1,0,1,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,
};

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    char op[16];
    
    scanf("%d", &t);
    rep(tt, 1, t+1) {
        getchar();
        int sum = 0;
        rep(i, 0, 8) {
            gets(op);
            int len = strlen(op);
            #ifndef ONLINE_JUDGE
            puts(op);
            #endif
            rep(j, 0, len) {
                if (op[j]=='y' || op[j]=='w')
                    sum += a[i][j];
            }    
        }
        printf("Case #%d: ", tt);
        puts(sum%3==0 ? "YES":"NO");
    }

    #ifndef ONLINE_JUDGE
        printf("time = %d.\n", (int)clock());
    #endif

    return 0;
}

2.3 HDOJ 3549
同样是一道2阶魔方，求由此时情况通过一定的操作序列实现复原。找到这样一个操作序列。
这题目是很早以前解掉的，基本算法是IDA*。启发式策略是至少经过多少次旋转能实现复原，这个策略是贪心的，实际操作可能多余这个H值。
因为2阶魔方大概10几步可能就解掉了，因此这算法性能还算不错。

/* 3459 */
#include <cstdio>
#include <cstring>
#include <cstdlib>

#define MAXN    10
#define MAXL    1005

#define U0        map[0][2]
#define U1        map[0][3]
#define U2        map[1][3]
#define U3        map[1][2]

#define F0        map[2][2]
#define F1        map[2][3]
#define F2        map[3][3]
#define F3        map[3][2]

#define R0        map[2][4]
#define R1        map[2][5]
#define R2        map[3][5]
#define R3        map[3][4]

#define L0        map[2][0]
#define L1        map[2][1]
#define L2        map[3][1]
#define L3        map[3][0]

#define B0        map[2][6]        
#define B1        map[2][7]
#define B2        map[3][7]
#define B3        map[3][6]

#define D0        map[4][2]
#define D1        map[4][3]
#define D2        map[5][3]
#define D3        map[5][2]


const int n = 6;
const int m = 8;
int deep;
char map[MAXN][MAXN];
char op[MAXL];

bool isValid() {
    bool ret;
    ret =\
        (U0==U1 && U0==U2 && U0==U3) &&\
        (L0==L1 && L0==L2 && L0==L3) &&\
        (R0==R1 && R0==R2 && R0==R3) &&\
        (F0==F1 && F0==F2 && F0==F3) &&\
        (B0==B1 && B0==B2 && B0==B3) &&\
        (D0==D1 && D0==D2 && D0==D3) ;
    return ret;    
}

void rotateX() {
    char ch, ch1, ch2;
    // handle right
    ch = R0;
    R0 = R1;
    R1 = R2;
    R2 = R3;
    R3 = ch;
    
    ch1 = F1;
    ch2 = F2;
    // up -> front
    F1 = U1;
    F2 = U2;
    // back -> up
    U1 = B3;
    U2 = B0;
    // down -> back
    B0 = D2;
    B3 = D1;
    // front -> down
    D1 = ch1;
    D2 = ch2;
}

void rotateY() {
    char ch, ch0, ch1;
    
    // handle up
    ch = U0;
    U0 = U1;
    U1 = U2;
    U2 = U3;
    U3 = ch;
    
    ch0 = F0;
    ch1 = F1;
    // left -> front
    F0 = L0;
    F1 = L1;
    // back -> left
    L0 = B0;
    L1 = B1;
    // right -> back
    B0 = R0;
    B1 = R1;
    // front -> right
    R0 = ch0;
    R1 = ch1;
}

void rotateZ() {
    char ch, ch2, ch3;
    
    // handle front
    ch = F0;
    F0 = F1;
    F1 = F2;
    F2 = F3;
    F3 = ch;
    
    ch2 = U2;
    ch3 = U3;
    // right -> up
    U3 = R0;
    U2 = R3;
    // down -> right
    R0 = D1;
    R3 = D0;
    // left -> down
    D0 = L1;
    D1 = L2;
    // up -> left
    L1 = ch2;
    L2 = ch3;
}

int getH(){
    int cnt = 0;
    if(map[2][0] != map[3][0] || map[2][7] != map[3][7])  cnt++;
    if(map[3][6] != map[3][7] || map[5][2] != map[5][3])  cnt++;
    if(map[4][2] != map[5][2] || map[3][0] != map[3][1])  cnt++;
    return cnt;
}

bool dfs(int d) {
    if (d+getH() > deep)
        return false;
    if (d == deep)
        return isValid();
    
    op[d] = 'X';
    rotateX();
    if (dfs(d+1))
        return true;
    rotateX();
    rotateX();
    rotateX();
    
    op[d] = 'Y';
    rotateY();
    if (dfs(d+1))
        return true;
    rotateY();
    rotateY();
    rotateY();
    
    
    op[d] = 'Z';
    rotateZ();
    if (dfs(d+1))
        return true;
    rotateZ();
    rotateZ();
    rotateZ();
    
    return false;
}

int main() {
    int i, j, k;
    
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    while (1) {
        for (i=0; i<n; ++i)
            scanf("%s", map[i]);
        if (map[0][2] == '.')
            break;
        deep = 0;
        while (1) {
            if (dfs(0))
                break;
            ++deep;
        }
        op[deep] = '\0';
        puts(op);
    }
    
    return 0;
}

2.4 HDOJ 2691
这题目当时直接拿哈希做的，其实直接转换成longlong兴许还能容易点儿。算法是双广，两种剪枝策略：任何操作的不能与它的逆操作邻接；同一种操作至多进行2次，否则一定可以使用更少操作次数的逆操作实现。这题我使用了找到任何一种魔方的等价态。不使用这个能不能过不清楚。flip函数的就是如何通过正立排列映射为倒立的排列。

/* 2691 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

typedef long long LL;
typedef unsigned long long ULL;

typedef struct {
    char a[24];
    short pre;
    short deep;
    
    void print() {
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 0, 2)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 2, 4)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        rep(i, 4, 10)     putchar(a[i]), putchar(' ');
        putchar('\n');
        rep(i, 10, 16)     putchar(a[i]), putchar(' ');
        putchar('\n');

        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 16, 18)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 18, 20)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 20, 22)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        rep(i, 0, 2)    putchar(' '), putchar(' ');
        rep(i, 22, 24)    putchar(a[i]), putchar(' ');
        rep(i, 0, 2)    putchar(' '), putchar(' ');
        putchar('\n');

        putchar('\n');
    }
} node_t;

int a[24], b[24];
int n;
int face[6][4] = {
    {0, 1, 2, 3},
    {4, 5, 10, 11},
    {6, 7, 12, 13},
    {8, 9, 14, 15},
    {16, 17, 18, 19},
    {20, 21, 22, 23}
};

int movp[6][24] = {
    {0,21,2,23,4,5,6,1,9,15,10,11,12,3,8,14,16,7,18,13,20,17,22,19},
    {0,7,2,13,4,5,6,17,14,8,10,11,12,19,15,9,16,21,18,23,20,1,22,3},
    {1,3,0,2,23,22,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,21,9,8},
    {2,0,3,1,6,7,8,9,23,22,10,11,12,13,14,15,16,17,18,19,20,21,5,4},
    {0,1,8,14,4,3,7,13,17,9,10,2,6,12,16,15,5,11,18,19,20,21,22,23},
    {0,1,11,5,4,16,12,6,2,9,10,17,13,7,3,15,14,8,18,19,20,21,22,23}
};
int nxt[4];
int unxt[4];
int ans;
vector<node_t> vc[8];

struct Hash {
    static const int mod = 23456;
    map<string,int> tb[mod];
    
    void clear() {
        rep(i, 0, mod)
            tb[i].clr();
    }

    static int HashCode(const char *s) {
        int ret = 0;

        rep(i, 0, 24)
            ret = (ret * 197 + s[i]) % mod;

        return ret;
    }
    
    static LL toLL(const char *s) {
        int ret = 0;
        rep(i, 0, 24)    ret = 10*ret + s[i];
        return ret;
    }

    bool find(const char* s) {
        int h = HashCode(s);
        return tb[h].count(string(s, 24)) > 0;
    }

    bool find(int h, const char *s) {
        return tb[h].count(string(s, 24)) > 0;
    }
    
    int get(const char *s) {
        int h = HashCode(s);
        return tb[h][string(s, 24)];
    }

    int get(int h, const char *s) {
        return tb[h][string(s, 24)];
    }

    void update(const char *s, int step) {
        int h = HashCode(s);
        map<string,int>& tb_ = tb[h];
        string ss(s, 24);
        if (tb_.find(ss) == tb_.end())
            tb_[ss] = step;
    }

    void update(const char *s, int h, int step) {
        map<string,int>& tb_ = tb[h];
        string ss(s, 24);
        if (tb_.find(ss) == tb_.end())
            tb_[ss] = step;
    }

};

Hash H[2];
void init_pos();

void init() {
    init_pos();
}

vector<vi> vpos;

vi flip(const vi& vtmp) {
    vi ret;

    per(i, 16, 20)     ret.pb(vtmp[i]);
    per(i, 10, 16)     ret.pb(vtmp[i]);
    per(i, 4, 10)      ret.pb(vtmp[i]);
    per(i, 0, 4)     ret.pb(vtmp[i]);
    per(i, 20, 24)     ret.pb(vtmp[i]);
    return ret;
}

#define push_vtmp2(a, b) {vtmp.pb(a); vtmp.pb(b);}
#define push_vtmp4(a, b, c, d) {vtmp.pb(a); vtmp.pb(b); vtmp.pb(c); vtmp.pb(d);}
#define push_vtmp6(a, b, c, d, e, f) {vtmp.pb(a); vtmp.pb(b); vtmp.pb(c); vtmp.pb(d); vtmp.pb(e); vtmp.pb(f);}
void init_pos() {
    vi vtmp;

    // 1
    vtmp.clr();
    push_vtmp4(0, 1, 2, 3);
    push_vtmp6(4, 5, 6, 7, 8, 9);
    push_vtmp6(10, 11, 12, 13, 14, 15);
    push_vtmp4(16, 17, 18, 19);
    push_vtmp4(20, 21, 22, 23);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(9, 15, 8, 14);
    push_vtmp6(1, 3, 7, 13, 17, 19);
    push_vtmp6(0, 2, 6, 12, 16, 18);
    push_vtmp4(5, 11, 4, 10);
    push_vtmp4(22, 20, 23, 21);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    

    // 2
    vtmp.clr();
    push_vtmp4(1, 3, 0, 2);
    push_vtmp6(23, 22, 4, 5, 6, 7);
    push_vtmp6(21, 20, 10, 11, 12, 13);
    push_vtmp4(18, 16, 19, 17);
    push_vtmp4(15, 14, 9, 8);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(7, 13, 6, 12);
    push_vtmp6(3, 2, 5, 11, 16, 17);
    push_vtmp6(1, 0, 4, 10, 18, 19);
    push_vtmp4(22, 20, 23, 21);
    push_vtmp4(9, 15, 8, 14);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 3
    vtmp.clr();
    push_vtmp4(2, 0, 3, 1);
    push_vtmp6(6, 7, 8, 9, 23, 22);
    push_vtmp6(12, 13, 14, 15, 21, 20);
    push_vtmp4(17, 19, 16, 18);
    push_vtmp4(11, 10, 5, 4);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(12, 6, 13, 7);
    push_vtmp6(16, 17, 14, 8, 3, 2);
    push_vtmp6(18, 19, 15, 9, 1, 0);
    push_vtmp4(21, 23, 20, 22);
    push_vtmp4(10, 4, 11, 5);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 4
    vtmp.clr();
    push_vtmp4(3, 2, 1, 0);
    push_vtmp6(8, 9, 23, 22, 4, 5);
    push_vtmp6(14, 15, 21, 20, 10, 11);
    push_vtmp4(19, 18, 17, 16);
    push_vtmp4(13, 12, 7, 6);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(5, 11, 4, 10);
    push_vtmp6(2, 0, 22, 20, 18, 16);
    push_vtmp6(3, 1, 23, 21, 19, 17);
    push_vtmp4(9, 15, 8, 14);
    push_vtmp4(7, 13, 6, 12);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 5
    vtmp.clr();
    push_vtmp4(20, 21, 22, 23);
    push_vtmp6(10, 4, 0, 1, 9, 15);
    push_vtmp6(11, 5, 2, 3, 8, 14);
    push_vtmp4(6, 7, 12, 13);
    push_vtmp4(16, 17, 18, 19);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(15, 14, 9, 8);
    push_vtmp6(21, 23, 1, 3, 7, 13);
    push_vtmp6(20, 22, 0, 2, 6, 12);
    push_vtmp4(4, 5, 10, 11);
    push_vtmp4(18, 16, 19, 17);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 6
    vtmp.clr();
    push_vtmp4(6, 7, 12, 13);
    push_vtmp6(5, 11, 16, 17, 14, 8);
    push_vtmp6(4, 10, 18, 19, 15, 9);
    push_vtmp4(20, 21, 22, 23);
    push_vtmp4(0, 1, 2, 3);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(8, 9, 14, 15);
    push_vtmp6(7, 13, 17, 19, 21, 23);
    push_vtmp6(6, 12, 16, 18, 20, 22);
    push_vtmp4(11, 10, 5, 4);
    push_vtmp4(2, 0, 3, 1);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
}

node_t bnode, enode;
queue<node_t> Q[2];

void Init() {
    rep(i, 0, 2) {
        while (!Q[i].empty()) Q[i].pop();
        H[i].clr();
    }
}

int update(node_t& nd, int idx, int step) {
    static char s[26];

    Hash& h = H[idx];
    Hash& hh = H[idx^1];
    const int sz = SZ(vpos);

    h.update(nd.a, step);
    rep(i, 0, sz) {
        rep(j, 0, 24)
            s[j] = nd.a[vpos[i][j]];
        int hval = Hash::HashCode(s);
        if (hh.find(hval, s))
            return step + hh.get(hval, s);
    }

    return -1;
}

int bfs(int idx, int step) {
    queue<node_t>& Q = ::Q[idx];
    Hash& h = H[idx];
    int sz = SZ(Q);
    node_t nd, d;
    int tmp;

    while (sz--) {
        nd = Q.front();
        Q.pop();
        rep(i, 0, 6) {
            if ((i^1) == nd.pre)
                continue;
            if (i != nd.pre) {
                rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                d.pre = i;
                d.deep = 1;

            } else if (nd.deep < 2) {
                rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                d.pre = i;
                d.deep = 2;
            } else {
                continue;
            }
            
            if (h.find(d.a))    continue;
            
            tmp = update(d, idx, step);
            if (tmp >= 0) {
                return tmp;
            } else {
                Q.push(d);
            }
        }
    }

    return -1;
}

void solve() {
    Init();
    
    update(bnode, 0, 0);
    if (update(enode, 1, 0) >= 0) {
        puts("0");
        return ;
    }
    Q[0].push(bnode);
    Q[1].push(enode);
    
    int ans = -1, tmp;

    for (int i=1; ;++i) {
        tmp = bfs(0, i);
        if (tmp >= 0) {
            ans = tmp;
            break;
        }
        tmp = bfs(1, i);
        if (tmp >= 0) {
            ans = tmp;
            break;
        }
    }

    printf("%d\n", ans);
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    int t;
    char s[24];
    int p[24];
    
    {
        int l = 0;
        rep(i, 0, 4) p[l++] = i;
        rep(i, 4, 10) p[l++] = i;
        p[l++] = 23; p[l++] = 22;
        rep(i, 10, 16) p[l++] = i;
        p[l++] = 21; p[l++] = 20;
        rep(i, 16, 20) p[l++] = i;
    }

    init();
    scanf("%d", &t);
    gets(s);
    while (t--) {
        int l = 0;
        rep(j, 0, 6) {
            gets(s);
            int len = strlen(s);
            rep(i, 0, len) {
                if (s[i] == ' ')    continue;
                bnode.a[p[l++]] = s[i];
            }
        }
        l = 0;
        rep(j, 0, 6) {
            gets(s);
            int len = strlen(s);
            rep(i, 0, len) {
                if (s[i] == ' ')    continue;
                enode.a[p[l++]] = s[i];
            }
        }
        bnode.pre = -1;
        enode.pre = -1;
        solve();
    }

    #ifndef ONLINE_JUDGE
        printf("time = %d.\n", (int)clock());
    #endif

    return 0;
}

2.5 HDOJ 1537 && POJ 1955
这道题目杭电上做的人不多，其实就是一道模拟，难在实现3阶魔方的旋转的映射排列。题目大意是给定魔方的状态及一串操作序列，求执行完后最终的魔方状态。
其中counter表示有给定的顺时针旋转，得到互逆的逆时针旋转。

/* 1537 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};

char s[56], d[56];
int q;
vector<vi> vpos;

vi counter(const vi& p) {
    int a[56], b[56];
    
    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }
    
    return vi(a, a+54);
}

void init() {
    int a[56], b[56];
    
    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }
    
    
    // rotate LEFT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate FRONT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate RIGHT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate BACK
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate Top
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate BOTTOM
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
}

void rotate(int f, int dir) {
    int idx = f * 2;
    if (dir == -1) idx += 1;
    memcpy(d, s, sizeof(d));
    vi& p = vpos[idx];
    #ifndef ONLINE_JUDGE
    assert(idx>=0 && idx<SZ(p));
    #endif
    rep(i, 0, 54) s[i] = d[p[i]];
}

void printAns(char *s) {
    int idx = 0;
    
    rep(i, 0, 3) {
        printf("     ");
        rep(j, 0, 3) {
            putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
    
    rep(i, 0, 3) {
        rep(j, 0, 12) {
            if (j) putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
    
    rep(i, 0, 3) {
        printf("     ");
        rep(j, 0, 3) {
            putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
}

void solve() {
    int f, d;
    
    while (q--) {
        scanf("%d%d", &f, &d);
        rotate(f, d);
    }
    printAns(s);
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    char op[4];
    
    init();
    scanf("%d", &t);
    rep(tt, 1, t+1) {
        rep(i, 0, 54) {
            scanf("%s", op);
            s[i] = op[0];
        }
        scanf("%d", &q);
        printf("Scenario #%d:\n", tt);
        solve();
        putchar('\n');
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif
    
    return 0;
}

2.6 HDOJ 2168
写完了上一道题，这道题也基本写完了，重新映射一下输入的三阶魔方以及输出结果。这题就直接过了。注意这道题没有逆时针旋转。题目数据非常弱，完全不用优化。

/* 2168 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};

const int maxl = 1015;
char ops[maxl];
char s[56], d[56];
int q;
vector<vi> vpos;
int ipos[54], ipos_[54];

vi counter(const vi& p) {
    int a[56], b[56];
    
    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }
    
    return vi(a, a+54);
}

void init() {
    int a[56], b[56];
    
    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }
    
    
    // rotate U
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    // rotate R
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    // rotate F
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    // rotate D
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    // rotate L
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    // rotate B
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
    }
    
    #ifndef ONLINE_JUDGE
    assert(SZ(vpos) == 6);
    memset(ipos, -1, sizeof(ipos));
    memset(ipos_, -1, sizeof(ipos_));
    #endif
    {
        int base;
        
        base = 0;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[LEFT][i*3+j]] = base + j;
            }
            base += 18;
        }
        
        base = 3;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[FRONT][i*3+j]] = base + j;
            }
            base += 18;
        }
        
        base = 6;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[BOTTOM][i*3+j]] = base + j;
            }
            base += 18;
        }
        
        base = 9;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[BACK][(2-i)*3+(2-j)]] = base + j;
            }
            base += 18;
        }
        
        base = 12;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[TOP][i*3+j]] = base + j;
            }
            base += 18;
        }
        
        base = 15;
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                ipos[face[RIGHT][j*3+2-i]] = base + j;
            }
            base += 18;
        }
        
        rep(i, 0, 54) {
            ipos_[ipos[i]] = i;
        }
    }
}

void rotate(char c1) {
    static char uc[] = "GYORWB";
    
    int idx = strchr(uc, c1) - uc;
    
    memcpy(d, s, sizeof(d));
    rep(j, 0, 54)
        s[j] = d[vpos[idx][j]];
}

void printAns() {
    rep(i, 0, 54) d[i] = s[ipos_[i]];
    rep(i, 0, 54) {
        if (i==17 || i==35 || i==53) {
            putchar(d[i]);
            putchar('\n');
        } else {
            putchar(d[i]);
            putchar(' ');
        }
    }
}

void solve() {
    int len = strlen(ops);
    
    rep(i, 0, 54) s[i] = d[ipos[i]];
    rep(i, 0, len) {
        rotate(ops[i]);
    }
    
    printAns();
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    char op[4];
    
    init();
    scanf("%d", &t);
    while (t--) {
        rep(i, 0, 54) {
            scanf("%s", op);
            d[i] = op[0];
        }
        scanf("%s", ops);
        solve();
        puts("===================================");
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif
    
    return 0;
}

2.7 HDOJ 2953
这题是个2阶魔方，但是比前面的题目难，难点在于需要对初始魔方进行一个映射。题目是需要是讲魔方复原。但是每个面的颜色存在着不同的组合，这也导致最终魔方的状态不等价。
重新映射后就可以利用预处理的结果了，过预处理的由结束状态魔方执行7步操作可达状态。如果不在预处理状态中，那么bfs找到最优解。

/* 2953 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

typedef long long LL;
typedef unsigned long long ULL;
typedef struct {
    char a[24];
    int pre, deep;
} node_t;

int a[24];
char s[24];
int face[6][4] = {
    {0, 1, 2, 3},
    {4, 5, 10, 11},
    {6, 7, 12, 13},
    {8, 9, 14, 15},
    {16, 17, 18, 19},
    {20, 21, 22, 23}
};
int movp[6][24] = {
    {0,21,2,23,4,5,6,1,9,15,10,11,12,3,8,14,16,7,18,13,20,17,22,19},
    {0,7,2,13,4,5,6,17,14,8,10,11,12,19,15,9,16,21,18,23,20,1,22,3},
    {1,3,0,2,23,22,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,21,9,8},
    {2,0,3,1,6,7,8,9,23,22,10,11,12,13,14,15,16,17,18,19,20,21,5,4},
    {0,1,8,14,4,3,7,13,17,9,10,2,6,12,16,15,5,11,18,19,20,21,22,23},
    {0,1,11,5,4,16,12,6,2,9,10,17,13,7,3,15,14,8,18,19,20,21,22,23}
};

ULL HashCode(const char *s) {
    ULL ret = 0;
    
    rep(i, 0, 24)
        ret = ret * 6 + s[i];
        
    return ret;
}

vector<vi> vpos;

struct Hash {
    map<ULL,int> tb;
    map<ULL,int>::iterator iter;
    
    void clear() {
        tb.clr();
    }
    
    int find(const char *b) {
        const int sz = SZ(vpos);
        static char a[24];
        
        rep(i, 0, sz) {
            rep(j, 0, 24)
                a[j] = b[vpos[i][j]];
            ULL h = HashCode(a);
            iter = tb.find(h);
            if (iter != tb.end())    return iter->sec;
        }
        
        return -1;
    }

    bool update(const char *b, int step) {
        const int sz = SZ(vpos);
        static char a[24];
        
        rep(i, 0, sz) {
            rep(j, 0, 24)
                a[j] = b[vpos[i][j]];
            ULL h = HashCode(a);
            if (tb.count(h) > 0)    return true;
        }
        
        ULL h = HashCode(b);
        tb[h] = step;
        return false;
    }
};

Hash H, HH;

vi flip(const vi& vtmp) {
    vi ret;

    per(i, 16, 20)     ret.pb(vtmp[i]);
    per(i, 10, 16)     ret.pb(vtmp[i]);
    per(i, 4, 10)      ret.pb(vtmp[i]);
    per(i, 0, 4)     ret.pb(vtmp[i]);
    per(i, 20, 24)     ret.pb(vtmp[i]);
    return ret;
}

#define push_vtmp2(a, b) {vtmp.pb(a); vtmp.pb(b);}
#define push_vtmp4(a, b, c, d) {vtmp.pb(a); vtmp.pb(b); vtmp.pb(c); vtmp.pb(d);}
#define push_vtmp6(a, b, c, d, e, f) {vtmp.pb(a); vtmp.pb(b); vtmp.pb(c); vtmp.pb(d); vtmp.pb(e); vtmp.pb(f);}
void init_pos() {
    vi vtmp;

    // 1
    vtmp.clr();
    push_vtmp4(0, 1, 2, 3);
    push_vtmp6(4, 5, 6, 7, 8, 9);
    push_vtmp6(10, 11, 12, 13, 14, 15);
    push_vtmp4(16, 17, 18, 19);
    push_vtmp4(20, 21, 22, 23);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(9, 15, 8, 14);
    push_vtmp6(1, 3, 7, 13, 17, 19);
    push_vtmp6(0, 2, 6, 12, 16, 18);
    push_vtmp4(5, 11, 4, 10);
    push_vtmp4(22, 20, 23, 21);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    

    // 2
    vtmp.clr();
    push_vtmp4(1, 3, 0, 2);
    push_vtmp6(23, 22, 4, 5, 6, 7);
    push_vtmp6(21, 20, 10, 11, 12, 13);
    push_vtmp4(18, 16, 19, 17);
    push_vtmp4(15, 14, 9, 8);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(7, 13, 6, 12);
    push_vtmp6(3, 2, 5, 11, 16, 17);
    push_vtmp6(1, 0, 4, 10, 18, 19);
    push_vtmp4(22, 20, 23, 21);
    push_vtmp4(9, 15, 8, 14);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 3
    vtmp.clr();
    push_vtmp4(2, 0, 3, 1);
    push_vtmp6(6, 7, 8, 9, 23, 22);
    push_vtmp6(12, 13, 14, 15, 21, 20);
    push_vtmp4(17, 19, 16, 18);
    push_vtmp4(11, 10, 5, 4);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(12, 6, 13, 7);
    push_vtmp6(16, 17, 14, 8, 3, 2);
    push_vtmp6(18, 19, 15, 9, 1, 0);
    push_vtmp4(21, 23, 20, 22);
    push_vtmp4(10, 4, 11, 5);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 4
    vtmp.clr();
    push_vtmp4(3, 2, 1, 0);
    push_vtmp6(8, 9, 23, 22, 4, 5);
    push_vtmp6(14, 15, 21, 20, 10, 11);
    push_vtmp4(19, 18, 17, 16);
    push_vtmp4(13, 12, 7, 6);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(5, 11, 4, 10);
    push_vtmp6(2, 0, 22, 20, 18, 16);
    push_vtmp6(3, 1, 23, 21, 19, 17);
    push_vtmp4(9, 15, 8, 14);
    push_vtmp4(7, 13, 6, 12);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 5
    vtmp.clr();
    push_vtmp4(20, 21, 22, 23);
    push_vtmp6(10, 4, 0, 1, 9, 15);
    push_vtmp6(11, 5, 2, 3, 8, 14);
    push_vtmp4(6, 7, 12, 13);
    push_vtmp4(16, 17, 18, 19);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(15, 14, 9, 8);
    push_vtmp6(21, 23, 1, 3, 7, 13);
    push_vtmp6(20, 22, 0, 2, 6, 12);
    push_vtmp4(4, 5, 10, 11);
    push_vtmp4(18, 16, 19, 17);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));

    // 6
    vtmp.clr();
    push_vtmp4(6, 7, 12, 13);
    push_vtmp6(5, 11, 16, 17, 14, 8);
    push_vtmp6(4, 10, 18, 19, 15, 9);
    push_vtmp4(20, 21, 22, 23);
    push_vtmp4(0, 1, 2, 3);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
    
    vtmp.clr();
    push_vtmp4(8, 9, 14, 15);
    push_vtmp6(7, 13, 17, 19, 21, 23);
    push_vtmp6(6, 12, 16, 18, 20, 22);
    push_vtmp4(11, 10, 5, 4);
    push_vtmp4(2, 0, 3, 1);
    vpos.pb(vtmp);
    vpos.pb(flip(vtmp));
}


void init_bfs() {
    queue<node_t> Q;
    node_t nd, d;
    
    rep(i, 0, 6)
        rep(j, 0, 4)
            nd.a[face[i][j]] = i;
    nd.pre = -1;
    nd.deep = 0;
    Q.push(nd);
    
    H.update(nd.a, 0);
    for (int step=1; step<=7; ++step) {
        int sz = SZ(Q);
        while (sz--) {
            nd = Q.front();
            Q.pop();
            rep(i, 0, 6) {
                if ((i^1) == nd.pre)
                    continue;
                if (i != nd.pre) {
                    rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                    d.pre = i;
                    d.deep = 1;
                    
                } else if (nd.deep < 2) {
                    rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                    d.pre = i;
                    d.deep = 2;
                } else {
                    continue;
                }
                
                if (!H.update(d.a, step)) {
                    Q.push(d);
                }
            }
        }
    }
}

void init() {
    init_pos();
    init_bfs();
}

int bfs() {
    int step = 0;
    queue<node_t> Q;
    node_t nd, d;
    
    rep(i, 0, 24) nd.a[i] = a[i];
    nd.pre = -1;
    nd.deep = 0;
    Q.push(nd);
    
    HH.update(nd.a, 0);
    
    while (1) {
        int sz = SZ(Q);
        if (sz == 0)    break;
        ++step;
        while (sz--) {
            nd = Q.front();
            Q.pop();
            rep(i, 0, 6) {
                if ((i^1) == nd.pre)
                    continue;
                if (i != nd.pre) {
                    rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                    d.pre = i;
                    d.deep = 1;
                    
                } else if (nd.deep < 2) {
                    rep(j, 0, 24)    d.a[j] = nd.a[movp[i][j]];
                    d.pre = i;
                    d.deep = 2;
                } else {
                    continue;
                }
                
                if (!HH.update(d.a, step)) {
                    int tmp = H.find(d.a);
                    if (tmp >= 0)    return step + tmp;
                    Q.push(d);
                }
            }
        }
    }
    
    return -1;
}

void solve() {
    static char b[24];
    rep(j, 0, 24) b[j] = a[j];
    int ans = H.find(b);
    
    if (ans >= 0) {
        printf("%d\n", ans);
        return ;
    }
    
    ans = bfs();
    printf("%d\n", ans);
}

inline int getVal(char c) {
    if (c == 'O')    return 0;
    if (c == 'W')    return 1;
    if (c == 'R')    return 2;
    if (c == 'G')    return 3;
    if (c == 'Y')    return 4;
    if (c == 'B')    return 5;
    return -1;
}

void transfer() {
    static int block[8][3]={
        {3,5,6}, {1,7,8}, {0,9,10}, {2,4,11},
        {12,19,20}, {13,14,21}, {15,16,23}, {17,18,22}
    };
    map<char,char> col;
    map<char,bool> flag;
    col[s[17]] = 'B'; 
    flag[s[17]] = true;
    col[s[18]] = 'W'; 
    flag[s[18]] = true;
    col[s[22]] = 'Y'; 
    flag[s[22]] = true;
    rep(i, 0, 7) {
        int cnt = 0, sum = 0, has = 3;
        if(flag[s[block[i][0]]]) {
            ++cnt;
            sum += col[s[block[i][0]]];
            has -= 0;
        }
        if(flag[s[block[i][1]]]) {
            ++cnt;
            sum += col[s[block[i][1]]];
            has -= 1;
        }
        if(flag[s[block[i][2]]]){
            ++cnt;
            sum+=col[s[block[i][2]]];
            has-=2;
        }
        if(cnt != 2) continue;
        if(sum == 'B'+'W') col[s[block[i][has]]] = 'O';
        if(sum == 'B'+'Y') col[s[block[i][has]]] = 'G';
        if(sum == 'Y'+'W') col[s[block[i][has]]] = 'R';
    }
    rep(i, 0, 24) s[i]=col[s[i]];
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    char ch;
    int p[24];
    
    {
        #define PUSHP(a, b, c, d) {p[l++]=a;p[l++]=b;p[l++]=c;p[l++]=d;}
        int l = 0;
        PUSHP(0, 1, 2, 3);
        PUSHP(6, 7, 8, 9);
        PUSHP(23, 22, 4, 5);
        PUSHP(12, 13, 14, 15);
        PUSHP(21, 20, 10, 11);
        PUSHP(16, 17, 18, 19);
    }
    
    init();
    scanf("%d", &t);
    rep(tt, 1, t+1) {
        rep(i, 0, 24) {
            while ((ch=getchar()) <= 32);
            s[i] = ch;
        }
        transfer();
        rep(i, 0, 24) a[p[i]] = getVal(s[i]);
        solve();
    }

    #ifndef ONLINE_JUDGE
        printf("time = %d.\n", (int)clock());
    #endif

    return 0;
}

2.8 HDOJ 4397
 三阶魔方，增加了X、Y、Z轴的旋转，一道模拟题。大写表示顺时针旋转，小写表示逆时针旋转，判定按照指定序列旋转后魔方能否复原。

/* 4397 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};

char ops[215];
char s[56], d[56];
int q;
vector<vi> vpos;

vi counter(const vi& p) {
    int a[56], b[56];
    
    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }
    
    return vi(a, a+54);
}

void init() {
    int a[56], b[56];
    
    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }
    
    
    // rotate U
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate R
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate F
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate D
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate L
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate B
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate X
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[LEFT][3], face[FRONT][3], face[LEFT][4], face[FRONT][4], face[LEFT][5], face[FRONT][5]);
        FORCE_MOVE(face[FRONT][3], face[RIGHT][3], face[FRONT][4], face[RIGHT][4], face[FRONT][5], face[RIGHT][5]);
        FORCE_MOVE(face[RIGHT][3], face[BACK][3], face[RIGHT][4], face[BACK][4], face[RIGHT][5], face[BACK][5]);
        FORCE_MOVE(face[BACK][3],face[LEFT][3],face[BACK][4],face[LEFT][4],face[BACK][5],face[LEFT][5]);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotateY
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[TOP][1], face[FRONT][1], face[TOP][4], face[FRONT][4], face[TOP][7], face[FRONT][7]);
        FORCE_MOVE(face[BACK][7], face[TOP][1], face[BACK][4], face[TOP][4], face[BACK][1], face[TOP][7]);
        FORCE_MOVE(face[BOTTOM][7], face[BACK][1], face[BOTTOM][4], face[BACK][4], face[BOTTOM][1], face[BACK][7]);
        FORCE_MOVE(face[FRONT][1],face[BOTTOM][1],face[FRONT][4],face[BOTTOM][4],face[FRONT][7],face[BOTTOM][7]);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotateZ
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[TOP][3], face[LEFT][7], face[TOP][4], face[LEFT][4], face[TOP][5], face[LEFT][1]);
        FORCE_MOVE(face[RIGHT][1], face[TOP][3], face[RIGHT][4], face[TOP][4], face[RIGHT][7], face[TOP][5]);
        FORCE_MOVE(face[BOTTOM][5], face[RIGHT][1], face[BOTTOM][4], face[RIGHT][4], face[BOTTOM][3], face[RIGHT][7]);
        FORCE_MOVE(face[LEFT][1],face[BOTTOM][3],face[LEFT][4],face[BOTTOM][4],face[LEFT][7],face[BOTTOM][5]);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
}

void rotate(char ch) {
    static char uc[] = "URFDLBXYZ";
    static char lc[] = "urfdlbxyz";
    
    int idx;
    
    if (islower(ch)) {
        idx = strchr(lc, ch) - lc;
        idx = (idx << 1) + 1;
        
    } else {
        idx = strchr(uc, ch) - uc;
        idx = (idx << 1);
    }
    
    #ifndef ONLINE_JUDGE
    assert(idx>=0 && idx<SZ(vpos));
    #endif
    
    memcpy(d, s, sizeof(d));
    rep(j, 0, 54)
        s[j] = d[vpos[idx][j]];
}

void printAns(char *s) {
    int idx = 0;
    
    rep(i, 0, 3) {
        printf("     ");
        rep(j, 0, 3) {
            putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
    
    rep(i, 0, 3) {
        rep(j, 0, 12) {
            if (j) putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
    
    rep(i, 0, 3) {
        printf("     ");
        rep(j, 0, 3) {
            putchar(' ');
            putchar(s[idx++]);
        }
        putchar('\n');
    }
}

void solve() {
    int len = strlen(ops);
    
    rep(i, 0, 54) s[i] = i;
    
    rep(i, 0, len) {
        rotate(ops[i]);
    }
    
    bool flag = true;
    rep(i, 0, 54) {
        if (s[i] != i) {
            flag = false;
            break;
        }
    }
    
    puts(flag ? "Yes":"No");
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t = 0;
    
    init();
    while (scanf("%s", ops)!=EOF) {
        if (t)
            putchar('\n');
        solve();
        ++t;
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif
    
    return 0;
}

2.9 POJ 1297
三阶魔方模拟，利用前面的代码稍微改改可以直接过了。

/* 1290 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};

char s[56], d[56];
int q;
vector<vi> vpos;

vi counter(const vi& p) {
    int a[56], b[56];
    
    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }
    
    return vi(a, a+54);
}

void init() {
    int a[56], b[56];
    
    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }
    
    
    // rotate LEFT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate FRONT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate RIGHT
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate BACK
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate Top
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate BOTTOM
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
}

void rotate(int x) {
    int v = abs(x) - 1;
    int idx = v * 2;
    if (x < 0) idx += 1;
    memcpy(d, s, sizeof(d));
    vi& p = vpos[idx];
    #ifndef ONLINE_JUDGE
    assert(idx>=0 && idx<SZ(p));
    #endif
    rep(i, 0, 54) s[i] = d[p[i]];
}

bool judge() {
    rep(i, 0, 6) {
        rep(j, 1, 9) {
            if (s[face[i][j]] != s[face[i][0]])
                return false;
        }
    }
    return true;
}

void solve() {
    int x;
    
    while (scanf("%d", &x)!=EOF && x) {
        rotate(x);
    }
    
    bool flag = judge();
    puts(flag ? "Yes, grandpa!" : "No, you are wrong!");
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    char op[4];
    
    init();
    scanf("%d", &t);
    rep(tt, 1, t+1) {
        rep(i, 0, 54) {
            scanf("%s", op);
            s[i] = op[0];
        }
        solve();
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif
    
    return 0;
}

2.10 POJ 3701
三阶魔方搜索，算法还是双广。但是这题wa了好几次，一定要注意读题，首先面1表示FRONT，同样旋转方式都是基于此前提下的，展开方式也是。因此，需要重新映射一下。这个题目不要使用状态等价，可以直接用longlong表示状态，因为$2^{54}$足够了，这里的1的个数一定为9。代码使用G++可以790ms过，C++一直超时。

/* 3701 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

typedef long long LL;
#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};

char s[56], d[56];
int one;
vector<vi> movp;
vector<vi> vpos;
map<LL, pair<LL,int> > tb[2];

vi counter(const vi& p) {
    int a[56], b[56];

    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }

    return vi(a, a+54);
}

void init_pos();
void init_bfs();
void init() {
    int a[56], b[56];

    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }

    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }

    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }

    // rotate U
    {

        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);

        vi vtmp(b, b+54);
        movp.pb(vtmp);
        movp.pb(counter(vtmp));
    }

    // rotate X
    {

        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[LEFT][3], face[FRONT][3], face[LEFT][4], face[FRONT][4], face[LEFT][5], face[FRONT][5]);
        FORCE_MOVE(face[FRONT][3], face[RIGHT][3], face[FRONT][4], face[RIGHT][4], face[FRONT][5], face[RIGHT][5]);
        FORCE_MOVE(face[RIGHT][3], face[BACK][3], face[RIGHT][4], face[BACK][4], face[RIGHT][5], face[BACK][5]);
        FORCE_MOVE(face[BACK][3],face[LEFT][3],face[BACK][4],face[LEFT][4],face[BACK][5],face[LEFT][5]);

        vi vtmp(b, b+54);
        movp.pb(vtmp);
        movp.pb(counter(vtmp));
    }

    // rotate D
    {
        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);

        vi vtmp(b, b+54);
        movp.pb(counter(vtmp));
        movp.pb(vtmp);
    }

    // rotate L
    {
        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);

        vi vtmp(b, b+54);
        movp.pb(counter(vtmp));
        movp.pb(vtmp);
    }

    // rotateY
    {

        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[TOP][1], face[FRONT][1], face[TOP][4], face[FRONT][4], face[TOP][7], face[FRONT][7]);
        FORCE_MOVE(face[BACK][7], face[TOP][1], face[BACK][4], face[TOP][4], face[BACK][1], face[TOP][7]);
        FORCE_MOVE(face[BOTTOM][7], face[BACK][1], face[BOTTOM][4], face[BACK][4], face[BOTTOM][1], face[BACK][7]);
        FORCE_MOVE(face[FRONT][1],face[BOTTOM][1],face[FRONT][4],face[BOTTOM][4],face[FRONT][7],face[BOTTOM][7]);

        vi vtmp(b, b+54);
        movp.pb(vtmp);
        movp.pb(counter(vtmp));
    }

    // rotate R
    {
        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);

        vi vtmp(b, b+54);
        movp.pb(vtmp);
        movp.pb(counter(vtmp));
    }

    // rotate B
    {
        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);

        vi vtmp(b, b+54);
        movp.pb(vtmp);
        movp.pb(counter(vtmp));
    }

    // rotateZ
    {

        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        FORCE_MOVE(face[TOP][3], face[LEFT][7], face[TOP][4], face[LEFT][4], face[TOP][5], face[LEFT][1]);
        FORCE_MOVE(face[RIGHT][1], face[TOP][3], face[RIGHT][4], face[TOP][4], face[RIGHT][7], face[TOP][5]);
        FORCE_MOVE(face[BOTTOM][5], face[RIGHT][1], face[BOTTOM][4], face[RIGHT][4], face[BOTTOM][3], face[RIGHT][7]);
        FORCE_MOVE(face[LEFT][1],face[BOTTOM][3],face[LEFT][4],face[BOTTOM][4],face[LEFT][7],face[BOTTOM][5]);

        vi vtmp(b, b+54);
        movp.pb(counter(vtmp));
        movp.pb(vtmp);
    }

    // rotate F
    {
        rep(i, 0, 54) a[i] = i;

        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);

        vi vtmp(b, b+54);
        movp.pb(counter(vtmp));
        movp.pb(vtmp);
    }
}

bool judge(char *s) {
    int c = 0;
    rep(j, 0, 9)
        c += s[face[FRONT][j]] - '0';
    
    return c == one;
}

inline LL zip(char *s) {
    LL ret = 0;

    rep(i, 0, 54) {
        if (s[i] == '1')
            ret |= 1LL << i;
    }

    return ret;
}

inline void unzip(char *s, LL val) {
    rep(i, 0, 54) {
        if (val & (1LL<<i))
            s[i] = '1';
        else
            s[i] = '0';
    }
}

struct node_t {
    LL st;
    int pre;
    int dep;

    node_t() {}
    node_t(LL st, int pre, int dep):
        st(st), pre(pre), dep(dep) {}
        
    void print() {
        char sa[55];
        unzip(sa, st);
        
        int idx = 0;
        
        printf("op = %d:\n", pre+1);
        rep(i, 0, 3) {
            printf("   ");
            rep(j, 0, 3) putchar(sa[idx++]);
            putchar('\n');
        }
        
        rep(i, 0, 3) {
            rep(j, 0, 12) putchar(sa[idx++]);
            putchar('\n');
        }
        
        rep(i, 0, 3) {
            printf("   ");
            rep(j, 0, 3) putchar(sa[idx++]);
            putchar('\n');
        }
        putchar('\n');
    }
};

inline bool Visit(LL st, int idx) {
    return tb[idx].count(st) > 0;
}

queue<node_t> Q[2];

LL bfs(int idx) {
    queue<node_t>& Q = ::Q[idx];
    map<LL, pair<LL,int> >& tb = ::tb[idx];
    const int sz = SZ(movp);
    int szQ = SZ(Q);
    node_t nd, d;
    static char sa[54], sb[54];

    while (szQ--) {
        nd = Q.front();
        Q.pop();
        unzip(sa, nd.st);
        rep(i, 0, sz) {
            if ((i^1) == nd.pre)    continue;
            if (i==nd.pre && nd.dep>=2)    continue;

            rep(j, 0, 54) sb[j] = sa[movp[i][j]];
            d.st = zip(sb);
            if (i != nd.pre) {
                d.dep = 1;
                d.pre = i;
            } else {
                d.dep++;
            }
            
            if (Visit(d.st, idx))    continue;
            tb[d.st] = mp(nd.st, i);
            if (Visit(d.st, idx^1))    return d.st;

            Q.push(d);
        }
        break;
    }

    return -1;
}

void solve() {
    int& c = one;
    
    c = 0;
    rep(i, 0, 54) {
        c += s[i] - '0';
    }

    if (judge(s)) {
        puts("yes");
        puts("1");
        puts("13");
        return ;
    }
        
    LL bst = zip(s);
    Q[0].push(node_t(bst, -1, -1));
    tb[0][bst] = mp(-1, -1);
    
    memset(s, '0', sizeof(s));
    rep(j, 0, 9) s[face[FRONT][j]] = '1';
    LL est = zip(s);
    Q[1].push(node_t(est, -1, -1));
    tb[1][est] = mp(-1, -1);
    
    LL st = -1;
    int t = 5000;
    while (!Q[0].empty() || !Q[1].empty()) {
        if (t-- == 0)    break;
        if (!Q[0].empty()) {
            st = bfs(0);
            if (st >= 0)    break;
        }
        if (!Q[1].empty()) {
            st = bfs(1);
            if (st >= 0)    break;
        }
    }
    
    if (st == -1) {
        puts("no");
        return ;
    }
    
    LL st1 = st;
    LL st2 = st;
    vi ans1, ans2;
    
    pair<LL,int> p;
    while (st1 != -1) {
        p = tb[0][st1];
        if (p.fir == -1)    break;
        ans1.pb(p.sec);
        st1 = p.fir;
    }
    while (st2 != -1) {
        p = tb[1][st2];
        if (p.fir == -1)    break;
        ans2.pb(p.sec);
        st2 = p.fir;
    }
    
    printf("yes\n%d\n", SZ(ans1)+SZ(ans2));
    per(i, 0, SZ(ans1)) {
        printf("%d\n", ans1[i]+1);
    }
    rep(i, 0, SZ(ans2)) {
        printf("%d\n", (ans2[i]^1)+1);
    }
    
    // rep(i, 0, 2) {
        // tb[i].clr();
        // while (!Q[i].empty()) Q[i].pop();
    // }
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    char ss[32];
    int p[] = {
                44, 43, 42,
                32, 31, 30,
                20, 19, 18,
    33, 21,  9,  0,     1,  2, 17, 29, 41, 53, 52, 51,
    34, 22, 10,  3,  4,  5, 16, 28, 40, 50, 49, 48,
    35, 23, 11,  6,  7,  8, 15, 27, 39, 47, 46, 45,
                12, 13, 14,
                24, 25, 26,
                36, 37, 38
    };

    init();
    int idx = 0;
    rep(i, 0, 9) {
        gets(ss);
        int len = strlen(ss);
        rep(i, 0, len) {
            if (ss[i]=='0' || ss[i]=='1')
                s[p[idx++]] = ss[i];
        }
    }
    assert(idx == 54);
    solve();

    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif

    return 0;
}

2.11 SPOJ IOPC1201
还是一个三阶魔方，给定一个操作序列，问最少执行多少次这个操作序列可以回到最初状态。题目看起来很来，实际很简单。一个操作序列其实就是从初始状态$p$到状态$q$的映射关系，可以将这个排列映射看成图，比如0->1->2->3->0。那么只要找到排列中的所有的环及其长度，这些长度的最小公倍数就是最优解了。这题挺简单的，做的人好少。

/* SPOJ */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")
 
#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1
 
inline int lcm(int a, int b) {
    int g = __gcd(a, b);
    return a/g*b;
}
 
#define LEFT     0
#define FRONT     1
#define RIGHT     2
#define BACK     3
#define TOP     4
#define BOTTOM     5
int face[6][9] = {
    /*Left*/    {9, 10, 11,  21, 22, 23, 33, 34, 35},
    /*Front*/    {12, 13, 14, 24, 25, 26, 36, 37, 38},
    /*Right*/    {15, 16, 17, 27, 28, 29, 39, 40, 41},
    /*Back*/    {18, 19, 20, 30, 31, 32, 42, 43, 44},
    /*Top*/        {0, 1, 2, 3, 4, 5, 6,  7, 8},
    /*Bottom*/    {45, 46, 47, 48, 49, 50, 51, 52, 53}
};
 
const int maxl = 1015;
char ops[maxl];
char s[56], d[56];
int q;
vector<vi> vpos;
 
vi counter(const vi& p) {
    int a[56], b[56];
    
    rep(i, 0, 54) a[i] = i;
    rep(i, 0, 3) {
        rep(j, 0, 54) b[j] = a[p[j]];
        memcpy(a, b, sizeof(b));
    }
    
    return vi(a, a+54);
}
 
void init() {
    int a[56], b[56];
    
    #define MOVE_ROW(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_ROW_(des, src)\
    {\
        rep(i, 6, 9)\
            b[face[des][i]] = a[face[src][i]];\
    }
    
    #define MOVE_COL(des, src)\
    {\
        rep(i, 0, 3)\
            b[face[des][i*3]] = a[face[src][i*3]];\
    }
    #define FORCE_MOVE(da, sa, db, sb, dc, sc)\
    {\
        b[da] = a[sa];\
        b[db] = a[sb];\
        b[dc] = a[sc];\
    }
    
    
    // rotate U
    {
        
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[TOP];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW(LEFT, FRONT);
        MOVE_ROW(FRONT, RIGHT);
        MOVE_ROW(RIGHT, BACK);
        MOVE_ROW(BACK, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate R
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[RIGHT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][2], face[FRONT][2], face[TOP][5], face[FRONT][5], face[TOP][8], face[FRONT][8]);    // MOVE_COL(TOP, FRONT);
        FORCE_MOVE(face[FRONT][2], face[BOTTOM][2], face[FRONT][5], face[BOTTOM][5], face[FRONT][8], face[BOTTOM][8]);    // MOVE_COL(FRONT, BOTTOM);
        FORCE_MOVE(face[BOTTOM][2], 42, face[BOTTOM][5], 30, face[BOTTOM][8], 18);    // MOVE_COL(BOTTOM, BACK);
        FORCE_MOVE(42, 2, 30, 5, 18, 8);    // MOVE_COL(BACK, TOP);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate F
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[FRONT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[TOP][6], face[LEFT][8], face[TOP][7], face[LEFT][5], face[TOP][8], face[LEFT][2]);    // MOVE_COL(TOP, LEFT);
        FORCE_MOVE(face[RIGHT][0], face[TOP][6], face[RIGHT][3], face[TOP][7], face[RIGHT][6], face[TOP][8]);    // MOVE_COL(RIGHT, TOP);
        FORCE_MOVE(face[BOTTOM][0], face[RIGHT][6], face[BOTTOM][1], face[RIGHT][3], face[BOTTOM][2], face[RIGHT][0]);    // MOVE_COL(BOTTOM, RIGHT);
        FORCE_MOVE(face[LEFT][2], face[BOTTOM][0], face[LEFT][5], face[BOTTOM][1], face[LEFT][8], face[BOTTOM][2]);    // MOVE_COL(LEFT, BOTTOM);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate D
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BOTTOM];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_ROW_(FRONT, LEFT);
        MOVE_ROW_(RIGHT, FRONT);
        MOVE_ROW_(BACK, RIGHT);
        MOVE_ROW_(LEFT, BACK);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate L
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[LEFT];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        MOVE_COL(FRONT, TOP);
        MOVE_COL(BOTTOM, FRONT);
        FORCE_MOVE(20, 51, 32, 48, 44, 45);    //MOVE_COL(BACK, BOTTOM);
        FORCE_MOVE(0, 44, 3, 32, 6, 20);    // MOVE_COL(TOP, BACK);    
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
    
    // rotate B
    {
        rep(i, 0, 54) a[i] = i;
        
        memcpy(b, a, sizeof(a));
        int* mf = face[BACK];
        rep(i, 0, 3) {
            rep(j, 0, 3) {
                b[mf[i*3+j]] = a[mf[(2-j)*3+i]];
            }
        }
        FORCE_MOVE(face[LEFT][0], face[TOP][2], face[LEFT][3], face[TOP][1], face[LEFT][6], face[TOP][0]);    // MOVE(LEFT, TOP);
        FORCE_MOVE(face[TOP][0], face[RIGHT][2], face[TOP][1], face[RIGHT][5], face[TOP][2], face[RIGHT][8]);    // MOVE(TOP, RIGHT);
        FORCE_MOVE(face[RIGHT][2], 53, face[RIGHT][5], 52, face[RIGHT][8], 51);    // MOVE(RIGHT, BOTTOM);
        FORCE_MOVE(53, face[LEFT][6], 52, face[LEFT][3], 51, face[LEFT][0]);    // MOVE(BOTTOM, LEFT);
        
        vi vtmp(b, b+54);
        vpos.pb(vtmp);
        vpos.pb(counter(vtmp));
    }
}
 
void rotate(char c1, char c2='\0') {
    static char uc[] = "URFDLB";
    
    int idx = strchr(uc, c1) - uc, n = 1;
    idx <<= 1;
    if (c2 == '2') {
        n++;
    } else if (c2 == '\'') {
        idx += 1;
    }
    
    #ifndef ONLINE_JUDGE
    assert(idx>=0 && idx<SZ(vpos));
    #endif
    
    rep(i, 0, n) {
        memcpy(d, s, sizeof(d));
        rep(j, 0, 54)
            s[j] = d[vpos[idx][j]];
    }
}
 
bool visit[54];
void solve() {
    int len = strlen(ops);
    int i = 0;
    char c1, c2;
    
    rep(i, 0, 54) s[i] = i;
    while (i < len) {
        c1 = ops[i];
        if (ops[i+1]=='\'' || ops[i+1]=='2') {
            c2 = ops[i+1];
            ++i;
        } else {
            c2 = '\0';
        }
        rotate(c1, c2);
        ++i;
    }
    
    memset(visit, false, sizeof(visit));
    int ans = 1;
    memcpy(d, s, sizeof(s));
    
    rep(i, 0, 54) {
        if (visit[i])    continue;
        int c = 1;
        visit[i] = true;
        
        int v = s[i];
        while (v != i) {
            visit[v] = true;
            ++c;
            v = s[v];
        }
        
        ans = lcm(ans, c);
    }
    
    printf("%d\n", ans);
}
 
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    
    init();
    scanf("%d", &t);
    while (t--) {
        scanf("%s", ops);
        solve();
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif
    
    return 0;
}
 

3. 总结
rubik魔方问题主要涉及IDA*，双广，哈希等算法，算是比较基本，但是实现起来稍微麻烦的问题。因为这类问题做的人不多，单独拎出来做个系列。下个系列打算做crossword。当年携程比赛就是几道难易程度不等的crossword，还是蛮有趣的。