zoukankan      html  css  js  c++  java
  • HDU

    题目链接

    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("
    ");
        }
    }
    
    
  • 相关阅读:
    E
    D
    Npp ChangeLog
    c++ 书籍(zz)
    再好的工作是为了更好的生活
    如何将JPG格式的图片转换成PNG格式
    点分治
    团体程序设计天梯赛(CCCC) L3021 神坛 的一些错误做法(目前网上的方法没一个是对的) 和 一些想法
    团体程序设计天梯赛(CCCC) L3019 代码排版 方法与编译原理密切相关,只有一个测试点段错误
    团体程序设计天梯赛(CCCC) L3015 球队“食物链” 状态压缩
  • 原文地址:https://www.cnblogs.com/Dup4/p/9433076.html
Copyright © 2011-2022 走看看