HDU1430 康托展开

这道题需要用到上一篇讲的康托展开与逆展开原理 跳转

题意：

Problem Description

在魔方风靡全球之后不久，Rubik先生发明了它的简化版——魔板。魔板由8个同样大小的方块组成，每个方块颜色均不相同，可用数字1-8分别表示。任一时刻魔板的状态可用方块的颜色序列表示：从魔板的左上角开始，按顺时针方向依次写下各方块的颜色代号，所得到的数字序列即可表示此时魔板的状态。例如，序列(1,2,3,4,5,6,7,8)表示魔板状态为：

1 2 3 4
8 7 6 5

对于魔板，可施加三种不同的操作，具体操作方法如下：

A: 上下两行互换,如上图可变换为状态87654321
B: 每行同时循环右移一格,如上图可变换为41236785
C: 中间4个方块顺时针旋转一格,如上图可变换为17245368

给你魔板的初始状态与目标状态，请给出由初态到目态变换数最少的变换步骤，若有多种变换方案则取字典序最小的那种。

Input

每组测试数据包括两行，分别代表魔板的初态与目态。

Output

对每组测试数据输出满足题意的变换步骤。

Sample Input

12345678
17245368
12345678
82754631

Sample Output

C
AC

思路：

上一篇举的例子就是这道题。在上一篇中我们说过，这道题无论把序列作为10进制或利用状压转成二进制都无法进行存储。因此需要利用康托展开的方式进行存储。

​ 因此，我们只需要利用BFS预处理出初状态为1,2,3,4,5,6,7,8到每种状态的最小步骤即可，然后利用map将1,2,3,4,5,6,7,8映射到真正的初始状态，然后利用该映射关系得到目标状态相对于1,2,3,4,5,6,7,8的状态目标状态值t，ans[t]即为结果，因此只需要预处理，其它查询都是O(1)操作

​

代码：

#include <stdio.h>
#include <string.h>
#include <map>
#include <queue>
#include <string>
#include <inttypes.h>
#include <algorithm>
#define d int32_t
#define ll int64_t
#define N 100000
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, star, endd) for (d i = star; i <= endd; i++)
#define Forr(i, endd, star) for (d i = endd; i >= star; i--)
using namespace std;

char s1[10], s2[10];
ll fact[10];
queue<ll> q;
bool book[N + 5];
bool flag[10];
string ans[N + 5];
map<d, d> zcy;

//逆康托展开
string inv_cantor (ll num) {
    string s = "";
    mem(flag);
    For(i, 0, 7) {
        ll t = num / fact[7 - i];
        num %= fact[7 - i];
        ll tot = -1;
        For(j, 1, 8) {
            if (!flag[j]) tot++;
            if (tot == t) {
                flag[j] = 1;
                s += ('0' + j);
                break;
            }
        }
    }
    return s;
}

//康托展开
ll cantor (string s) {
    ll res = 0;
    For(i, 0, 7) {
        d tot = 0;
        For (j, i + 1, 7) {
            if (s[i] > s[j]) tot++;
        }
        res += tot * fact[7 - i];
    }
    return res;
}

//三种操作
string chooes (string s, d inv) {
    if (inv == 0) {
        For(i, 0, 3) {
            swap(s[i], s[7 - i]);
        }
    } else if (inv == 1){
        Forr(i, 3, 1) {
            swap(s[i], s[i - 1]);
        }
        For(i, 4, 6) {
            swap(s[i], s[i + 1]);
        }
    } else {
        swap(s[1], s[2]);
        swap(s[1], s[5]);
        swap(s[1], s[6]);
    }
    return s;
}

//预处理开始为1,2,3,4,5,6,7,8到各个状态的最小步数
void init () {
    mem(fact);
    mem(book);
    while (!q.empty()) {
        q.pop();
    }
    fact[0] = fact [1] = 1;
    For(i, 2, 7) {				//预处理阶乘
        fact[i] = fact[i - 1] * i;
    }
    book[0] = 1;
    q.push(0);
    while (!q.empty()) {
        ll num = q.front();
        q.pop();
        string s = inv_cantor (num);
        For(i, 0, 3) {					//保证字典序最小
            string ss = chooes (s, i);
            ll num1 = cantor(ss);
            if (!book[num1]) {
                q.push(num1);
                book[num1] = 1;
                ans[num1] = ans[num] + (char)('A' + i);
            }
        }
    }
    return;
}

d main () {
    init ();
    while (scanf("%s", s1 + 1) == 1) {
        scanf("%s", s2 + 1);
        zcy.clear();
        string s = "";
        For(i, 1, 8) {					//利用映射关系把初始转化为12345678的序列,目标序列随之改变
            zcy[s1[i] - '0'] = i;
        }
        For(i, 1, 8) {
            s += ('0' + zcy[s2[i] - '0']);
        }
        ll num = cantor(s);
        printf("%s\n", ans[num].data());
    }
    return 0;
}

转载请注明出处！！！

如果有写的不对或者不全面的地方 可通过主页的联系方式进行指正，谢谢