【HDOJ】1667 The Rotation Game

1. 题目描述
有个#字型的条带，可以从横线或竖线进行循环移动，求通过各种移动最终使中心的8个字符全等的长度最短并相同长度字典序最小的操作序列。

2. 基本思路
24个数据，8种移动方式，数据量很小了，所以基本怎么玩儿都可以。
需要注意的是因为横线竖线间有交点，所以每个条带的数据可能都是变化的。
采用IDA*算法可解。
所谓IDA*，就是不断对所求操作需要长度进行增加，然后不断当前长度是否存在可行的操作序列。
判断是否存在可行操作序列的方法是深搜，这里需要注意去除先移动A紧接着移动F的类似情况。
H函数的基本想法很简单，即判断中心8个字符的最少改变几个就可以满足条件。

3. 代码

/* 1667 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#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

const int INF = 0x3f3f3f3f;
const int maxl = 300;
int op[maxl];
int a[24];
int pos[8][7] = {
    {0, 2, 6, 11, 15, 20, 22},
    {1, 3, 8, 12, 17, 21, 23},
    {10, 9, 8, 7, 6, 5, 4},
    {19, 18, 17, 16, 15, 14, 13}
};
int eight[8] = {
    6, 7, 8, 11, 12, 15, 16, 17
};
int mirror[8] = {
    5, 4, 7, 6, 1, 0, 3, 2
};
bool flag;
int v;

void Init() {
    rep(i, 0, 4) {
        int j = mirror[i];
        memcpy(pos[j], pos[i], sizeof(pos[j]));
        reverse(pos[j], pos[j]+7);
    }
}

void Rotate(int *a, int d) {
    int tmp = a[pos[d][0]];
    rep(i, 1, 7)
        a[pos[d][i-1]] = a[pos[d][i]];
    a[pos[d][6]] = tmp;
}

int H(int *a) {
    int c[4];
    
    c[1] = c[2] = c[3] = 0;
    rep(i, 0, 8)
        ++c[a[eight[i]]];
    
    return 8 - max(c[1], max(c[2], c[3]));
}

void dfs(int *a, int dep, int fa) {
    int mn = H(a);
    
    if (dep < mn)
        return ;
    
    if (dep == 0) {
        if (mn == 0) {
            flag = true;
            v = a[eight[0]];
        }
        return ;
    }
    
    int b[24];
    
    rep(i, 0, 8) {
        if (mirror[i] == fa)
            continue;
        op[dep] = i;
        memcpy(b, a, sizeof(b));
        Rotate(b, i);
        dfs(b, dep-1, i);
        if (flag)    return ;
    }
}

void solve() {
    int mn = H(a);
    
    if (mn == 0) {
        printf("No moves needed
%d
", a[eight[0]]);
        return ;
    }
    
    flag = false;
    for (int l=mn; ; ++l) {
        dfs(a, l, -1);
        if (flag) {
            per(i, 1, l+1) {
                putchar('A'+op[i]);
            }
            printf("
%d
", v);
            break;
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    Init();
    while (scanf("%d", &a[0])!=EOF && a[0]) {
        rep(i, 1, 24)
            scanf("%d", &a[i]);
        solve();
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %d.
", (int)clock());
    #endif
    
    return 0;
}

4. 数据生成器。

/*
2 3 2 2 1 1 3 1 3 2 2 1 2 2 2 3 3 2 3 1 2 2 2 2
2 3 2 1 2 1 1 2 1 2 2 3 2 2 2 2 2 2 1 3 3 2 2 2
1 1 3 1 3 3 1 3 3 3 1 3 2 1 2 2 1 3 3 3 1 3 3 3
1 2 1 1 1 2 1 2 1 3 1 2 1 2 2 1 1 1 1 1 2 1 3 1
3 2 3 3 3 2 3 3 1 2 3 3 3 1 3 1 2 1 3 3 2 3 2 3
2 2 3 2 3 3 2 1 3 2 2 3 1 2 2 2 2 2 1 2 1 2 3 2
3 2 1 1 3 3 3 1 2 3 3 3 2 3 1 3 3 3 3 3 1 1 3 3
3 2 3 3 3 2 2 1 1 3 1 3 3 3 2 3 3 3 1 3 3 3 3 2
1 3 2 1 1 3 1 1 1 3 3 1 1 1 3 3 3 2 1 1 2 1 1 2
1 1 3 3 2 3 1 3 2 3 2 1 3 1 2 2 2 1 1 2 2 2 3 2
0
*/

/*
AABDDHA
2
BFFF
2
BBGGH
3
AGHBH
1
GBGF
3
ABBHHF
2
BCCEC
3
BHA
3
EGG
1
ADHBBH
2
*/

from copy import deepcopy
from random import randint, shuffle
import shutil
import string


def GenDataIn():
    with open("data.in", "w") as fout:
        t = 10
        bound = 10**5
        # fout.write("%d
" % (t))
        for tt in xrange(t):
            n1 = randint(10, 15)
            token = randint(1, 3)
            L = [token for i in xrange(n1)]
            op = range(1, 4)
            op.remove(token)
            for i in xrange(24-n1):
                idx = randint(0, 1)
                x = op[idx]
                L.append(x)
            shuffle(L)
            fout.write(" ".join(map(str, L)) + "
")
        fout.write("0
")    
            
def MovDataIn():
    desFileName = "F:eclipse_prjworkspacehdojdata.in"
    shutil.copyfile("data.in", desFileName)

    
if __name__ == "__main__":
    GenDataIn()
    MovDataIn()