【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 = ;
 int op[maxl];
 int a[];
 int pos[][] = {
     {, , , , , , },
     {, , , , , , },
     {, , , , , , },
     {, , , , , , }
 };
 int eight[] = {
     , , , , , , ,
 };
 int mirror[] = {
     , , , , , , ,
 };
 bool flag;
 int v;

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

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

 int H(int *a) {
     int c[];

     c[] = c[] = c[] = ;
     rep(i, , )
         ++c[a[eight[i]]];

     return  - max(c[], max(c[], c[]));
 }

 void dfs(int *a, int dep, int fa) {
     int mn = H(a);

     if (dep < mn)
         return ;

     if (dep == ) {
         if (mn == ) {
             flag = true;
             v = a[eight[]];
         }
         return ;
     }

     int b[];

     rep(i, , ) {
         if (mirror[i] == fa)
             continue;
         op[dep] = i;
         memcpy(b, a, sizeof(b));
         Rotate(b, i);
         dfs(b, dep-, i);
         if (flag)    return ;
     }
 }

 void solve() {
     int mn = H(a);

     if (mn == ) {
         printf("No moves needed\n%d\n", a[eight[]]);
         return ;
     }

     flag = false;
     for (int l=mn; ; ++l) {
         dfs(a, l, -);
         if (flag) {
             per(i, , l+) {
                 putchar('A'+op[i]);
             }
             printf("\n%d\n", 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[])!=EOF && a[]) {
         rep(i, , )
             scanf("%d", &a[i]);
         solve();
     }

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

     return ;
 }

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\n" % (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)) + "\n")
         fout.write("0\n")    

 def MovDataIn():
     desFileName = "F:\eclipse_prj\workspace\hdoj\data.in"
     shutil.copyfile("data.in", desFileName)

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