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");
    }
}

转载于:https://www.cnblogs.com/Dup4/p/9433076.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值