HDU - 1430 魔板 【BFS + 康托展开 + 哈希】

题目链接

http://acm.hdu.edu.cn/showproblem.php?pid=1430

思路

我刚开始 想到的 就是 康托展开

但是这个题目是 多组输入 即使用 康托展开 也是会T的

正解应该是 预处理

然后我想到的预处理

因为每个状态 都是能够扩展出三种状态的

也就是说 每个状态都可以有三个儿子 这样 就像一棵树

我先把这棵树 建好 然后 询问的时候 再BFS搜索 这样就不用每次都康托展开了

但是还是T了

后来查了题解

发现 其实每次变换的都是位置，而上面的数字 是什么 其实不重要 我们可以给它哈希成 12345678

比如说 给出的 初始状态是 8 2 7 5 4 6 3 1 目标状态是 1 7 2 4 5 3 6 8

那么 我们可以理解为

8-1

2-2

7-3

5-4

4-5

6-6

3-7

1-8

那么 目标状态 通过哈希 就变为

8 3 2 5 4 7 6 1

问题就转化为

从 1 2 3 4 5 6 7 8 转移到 8 3 2 5 4 7 6 1 需要多少步骤

那么我们就可以 从 1 2 3 4 5 6 7 8 到达任意一种状态都预处理

这样 就可以直接输出路径了。。

我是这样处理的

保存父节点 递归输出

AC代码

#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <stack>
#include <set>
#include <list>
#include <numeric>
#include <sstream>
#include <iomanip>
#include <limits>

#define CLR(a, b) memset(a, (b), sizeof(a))
#define pb push_back
#define bug puts("***bug***");
#define fi first
#define se second
#define stack_expand #pragma comment(linker, "/STACK:102400000,102400000")
#define syn_close   ios::sync_with_stdio(false);cin.tie(0);
//#define bug
//#define gets gets_s

using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <string, int> psi;
typedef pair <string, string> pss;
typedef pair <double, int> pdi;

const double PI = acos(-1.0);
const double E = exp(1.0);
const double eps = 1e-8;

const int INF = 0x3f3f3f3f;
const int maxn = 4e4 + 1e3 + 10;
const int MOD = 142857;

const int FAC[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };

int cantor(int b[8])
{
    int ans = 0;
    for (int i = 0; i < 8; i++)
    {
        int smaller = 0;
        for (int j = i + 1; j < 8; j++)
        {
            if (b[i] > b[j])
                smaller++;
        }
        ans += FAC[7 - i] * smaller;
    }
    return ans;
}

int arr[8];

pii pre[maxn];

int visit[maxn];

struct node
{
    int arr[8];
    int root;
};

void bfs()
{
    for (int i = 0; i < maxn; i++)
        visit[i] = 0;
    int flag;
    queue <node> q;
    node u;
    u.root = 0;
    for (int i = 0; i < 8; i++)
        u.arr[i] = i + 1;
    q.push(u);
    visit[0] = 1;
    pre[0] = pii(-1, -1);
    while (!q.empty())
    {
        node u = q.front(), vv;
        q.pop();
        // A
        vv.arr[0] = u.arr[7];
        vv.arr[1] = u.arr[6];
        vv.arr[2] = u.arr[5];
        vv.arr[3] = u.arr[4];
        vv.arr[4] = u.arr[3];
        vv.arr[5] = u.arr[2];
        vv.arr[6] = u.arr[1];
        vv.arr[7] = u.arr[0];
        flag = cantor(vv.arr);
        if (visit[flag] == 0)
        {
            visit[flag] = 1;
            vv.root = flag;
            pre[flag] = pii(u.root, 1);
            q.push(vv);
        }
        // B
        vv.arr[0] = u.arr[3];
        vv.arr[1] = u.arr[0];
        vv.arr[2] = u.arr[1];
        vv.arr[3] = u.arr[2];
        vv.arr[4] = u.arr[5];
        vv.arr[5] = u.arr[6];
        vv.arr[6] = u.arr[7];
        vv.arr[7] = u.arr[4];
        flag = cantor(vv.arr);
        if (visit[flag] == 0)
        {
            visit[flag] = 1;
            vv.root = flag;
            pre[flag] = pii(u.root, 2);
            q.push(vv);
        }
        // C
        vv.arr[0] = u.arr[0];
        vv.arr[1] = u.arr[6];
        vv.arr[2] = u.arr[1];
        vv.arr[3] = u.arr[3];
        vv.arr[4] = u.arr[4];
        vv.arr[5] = u.arr[2];
        vv.arr[6] = u.arr[5];
        vv.arr[7] = u.arr[7];
        flag = cantor(vv.arr);
        if (visit[flag] == 0)
        {
            visit[flag] = 1;
            vv.root = flag;
            pre[flag] = pii(u.root, 3);
            q.push(vv);
        }
    }
}

int ed;

vector <int> ans;

void solve()
{
    ans.clear();
    while (pre[ed].fi != -1)
    {
        ans.pb(pre[ed].se);
        ed = pre[ed].fi;
    }
}

int main()
{
    bfs();
    string s1, s2;
    while (cin >> s1 >> s2)
    {
        int arr[8];
        map <char, int> mp;
        for (int i = 0; i < 8; i++)
            mp[s1[i]] = i + 1;
        for (int i = 0; i < 8; i++)
            arr[i] = mp[s2[i]];
        ed = cantor(arr);
        solve();
        int len = ans.size();
        for (int i = len - 1; i >= 0; i--)
            printf("%c", 'A' + ans[i] - 1);
        printf("\n");
    }
}