POJ 1077 Eight & HDU 1043 Eight（康托展开+BFS）

最新推荐文章于 2020-03-18 15:43:01 发布
最新推荐文章于 2020-03-18 15:43:01 发布
阅读量391 收藏
点赞数
分类专栏： 搜索 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Noooooorth/article/details/51893903
版权

题目链接：1077 -- Eight Problem - 1043

两个题目几乎完全一致。不同的是，HDU的八数码这道题需要一次bfs，起点为123456789X，遍历完所有状态，同时用pre数组记录上一个状态，然后每次输入只需要一个while进行O（1）的查询。

方法没有什么特殊的，我用的是普通的bfs。这道题和其他的搜索题目不一样的一点是，9个格子，太大没有办法标记。这时可以利用康托展开。

康托展开是一个完美hash函数，可以将n个数的所有排列组合状态进行压缩。9个数进行全排列，记录状态需要大小1e10的数组，经过康托展开的映射后只需要大小为9！的数组。一个数组经过这个过程，可以得到这个数组在全排列的序号。比如213是组合{1， 2， 3}中的第2小的组合（下标从0开始）。那么该如何得到213的康托展开就由1*2!+0*1!+0*0!得到。第一位是2，当第一位的数小于2时，排列数一定小于213，比如123、132，所以有1*2！，再看小于第二位1的，小于2的数没有 所以有0*1!=0，所以小于213的{1,2,3}排列数有1*2!+0*1!=2个，所以213是第3个大的数。


POJ 1077

#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
#define FIN freopen("in.txt", "r", stdin);
#define FOUT freopen("out.txt", "w", stdout);
const int INF = 0x3f3f3f3f;

const int MAXN = 400005;

char op[MAXN];
int pre[MAXN], fac[55];
bool vis[MAXN], flag;


int CantorExpansion(LL m)
{
    int str[10], pos = 8;
    while (m)
    {
        str[pos--] = m % 10;
        m /= 10;
    }
    int ret = 0;
    for (int i = 0; i < 8; i++)
    {
        int tmp = 0;
        for (int j = i + 1; j < 9; j++)
            if (str[i] > str[j])
                tmp++;
        ret += tmp * fac[8 - i];
    }
    return ret;
}

void bfs(LL start)
{
    memset(vis, false, sizeof(vis));
    memset(op, -1, sizeof(op));
    queue<LL> q;
    int id;
    q.push(start);
    id = CantorExpansion(start);
    vis[id] = true;
    while (!q.empty())
    {
        LL cur = q.front();
        q.pop();
        if (cur == 123456789)
        {
            stack<char> sta;
            id = CantorExpansion(cur);
            while (op[id] != -1)
            {
                sta.push(op[id]);
                id = pre[id];
            }
            while (!sta.empty())
            {
                printf("%c", sta.top());
                sta.pop();
            }
            puts("");
            flag = true;
            return;
        }
        int str[10], pos = 8, nine;
        LL tcur = cur;
        while (tcur)
        {
            if (tcur % 10 == 9)
                nine = pos;
            str[pos--] = tcur % 10;
            tcur /= 10;
        }
        for (int i = 0; i < 4; i++)
        {
            if ((i == 0 && nine / 3 == 0) || (i == 1 && nine / 3 == 2) || (i == 2 && nine % 3 == 0) || (i == 3 && nine % 3 == 2))
                continue;
            int tstr[10];
            memcpy(tstr, str, 9 * sizeof(int));
            if (i == 0)
                swap(tstr[nine], tstr[nine - 3]);
            else if (i == 1)
                swap(tstr[nine], tstr[nine + 3]);
            else if (i == 2)
                swap(tstr[nine], tstr[nine - 1]);
            else if (i == 3)
                swap(tstr[nine], tstr[nine + 1]);
            LL tt = 0;
            for (int i = 0; i < 9; i++)
                tt = tt * 10 + tstr[i];
            int id = CantorExpansion(tt);
            if (!vis[id])
            {
                if (i == 0)
                    op[id] = 'u';
                else if (i == 1)
                    op[id] = 'd';
                else if (i == 2)
                    op[id] = 'l';
                else if (i == 3)
                    op[id] = 'r';
                pre[id] = CantorExpansion(cur);
                vis[id] = true;
                q.push(tt);
            }
        }
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    //bfs();
    fac[0] = fac[1] = 1;
    for (int i = 2; i < 9; i++)
        fac[i] = fac[i - 1] * i;
    char str[50];
    while (gets(str))
    {
        flag = false;
        int s = 0;
        for (int i = 0; str[i]; i++)
        {
            if (str[i] == 'x')
                s = s * 10 + 9;
            else if (str[i] != ' ')
                s = s * 10 + str[i] - '0';
        }
        int id = CantorExpansion(s);
        if (id == 0)
        {
            printf("lr\n");
            continue;
        }
        bfs(s);
        if (!flag)
            printf("unsolvable\n");
    }
    return 0;
}


HDU 1043

#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
#define FIN freopen("in.txt", "r", stdin);
#define FOUT freopen("out.txt", "w", stdout);
const int INF = 0x3f3f3f3f;

const int MAXN = 400005;

char op[MAXN];
int pre[MAXN], fac[55];
bool vis[MAXN];


int CantorExpansion(LL m)
{
    int str[10], pos = 8;
    while (m)
    {
        str[pos--] = m % 10;
        m /= 10;
    }
    int ret = 0;
    for (int i = 0; i < 8; i++)
    {
        int tmp = 0;
        for (int j = i + 1; j < 9; j++)
            if (str[i] > str[j])
                tmp++;
        ret += tmp * fac[8 - i];
    }
    return ret;
}

void bfs()
{
    fac[0] = fac[1] = 1;
    for (int i = 2; i < 9; i++)
        fac[i] = fac[i - 1] * i;
    memset(vis, false, sizeof(vis));
    memset(op, -1, sizeof(op));
    queue<LL> q;
    int id;
    q.push(123456789);
    id = CantorExpansion(123456789);
    vis[id] = true;
    while (!q.empty())
    {
        LL cur = q.front();
        q.pop();
        int str[10], pos = 8, nine;
        LL tcur = cur;
        while (tcur)
        {
            if (tcur % 10 == 9)
                nine = pos;
            str[pos--] = tcur % 10;
            tcur /= 10;
        }
        for (int i = 0; i < 4; i++)
        {
            if ((i == 0 && nine / 3 == 0) || (i == 1 && nine / 3 == 2) || (i == 2 && nine % 3 == 0) || (i == 3 && nine % 3 == 2))
                continue;
            int tstr[10];
            memcpy(tstr, str, 9 * sizeof(int));
            if (i == 0)
                swap(tstr[nine], tstr[nine - 3]);
            else if (i == 1)
                swap(tstr[nine], tstr[nine + 3]);
            else if (i == 2)
                swap(tstr[nine], tstr[nine - 1]);
            else if (i == 3)
                swap(tstr[nine], tstr[nine + 1]);
            LL tt = 0;
            for (int i = 0; i < 9; i++)
                tt = tt * 10 + tstr[i];
            int id = CantorExpansion(tt);
            if (!vis[id])
            {
                if (i == 0)
                    op[id] = 'd';
                else if (i == 1)
                    op[id] = 'u';
                else if (i == 2)
                    op[id] = 'r';
                else if (i == 3)
                    op[id] = 'l';
                pre[id] = CantorExpansion(cur);
                vis[id] = true;
                q.push(tt);
            }
        }
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    bfs();
    char str[50];
    while (gets(str))
    {
        int s = 0;
        for (int i = 0; str[i]; i++)
        {
            if (str[i] == 'x')
                s = s * 10 + 9;
            else if (str[i] != ' ')
                s = s * 10 + str[i] - '0';
        }
        int id = CantorExpansion(s);
        if (id == 0)
        {
            printf("lr\n");
            continue;
        }
        if (op[id] == -1)
        {
            printf("unsolvable\n");
            continue;
        }
        while (id != 0)
        {
            printf("%c", op[id]);
            id = pre[id];
        }
        puts("");
    }
    return 0;
}


Noooooorth
关注
专栏目录
POJ1077(经典的八数码问题)
飞翔的小鸟
08-05 3705
很经典的八数码问题，可以用单向广度优先搜索、双向广度优先搜索、A*算法、IDA算法解。 用了双向广度优先搜索和A*算法解，在用A*算法时，纠结了好几天，后来在网上看了一份博客才发现自己错在哪。之后解出来了。虽然做这题时很纠结，不过收获真的很大，痛而快乐着………… 下面贴出用双向广度优先搜索和A*算法做的代码   //A*算法 #include #include #include
poj 1077 Eight 八数码问题( 康拓展开+BFS状态压缩)
woshinannan的专栏
07-12 1697
传送门：poj 1077 Eight题目大意输入的八数码 将一个八数码最后转换为 1 2 3 4 5 6 7 8 x 的格式，然后打印出路径康拓展开如果按照平常的思路，把x的位置看做0，一共有8！个状态，来判断某一个状态是否被访问过。 但是问题来了？怎么把一个带有x的数组转变为转变为数字呢？第一个联想到的就是STL中的map，但是map的速度太慢了，会超时，这个时候我们就要用一种快速的
poj1077
weixin_34075551的博客
07-19 73
题意：给出一个八数码问题，求解法，不可解则输出unsolvable。 分析：可以用ida*算法，估价函数可以使用每个数码到其最终位置的最短距离之和。对于不可解的判断，我这里用迭代深度大于100时判定为不可解。 还有一种更高级的无解判断方法。就是将八数码矩阵中的空格忽略，然后将8个数字排成一排，第二行接在第一行后面，第三行接在第二行后面，通过观察我们发现移动空格不会影响这个8个数字组成的数列中逆...
用 A* 解决八数码问题
hazqfp的专栏
02-27 968
#include 8 s% W2 b- F3 j$ Y4 o #include 3 _  h, ^$ P9 ?/ ? #include using namespace std; 9 S+ n& Q  g  R4 y #define HEAP_PARENT(i)                        (i >> 1); n- q# z9 x0 {. O
POJ 1077
一只菜鸟夹
07-07 458
https://blog.csdn.net/mjj1024/article/details/80047648 https://blog.csdn.net/a799581229/article/details/38925697
poj 1077 Eight.md
11-17
poj 1077 Eight.md
POJ1077 Eight A*
Kevin的博客
09-11 394
题目链接 http://poj.org/problem?id=1077 分析 直接用BFS进行状态扩展会超时，需要设计估价函数跑A*算法。 每次只能使一个数位置改变，因此未来的操作次数不会小于每个数当前位置于最终位置的曼哈顿距离之和。 用这个作为估价函数，用康托展开将排列映射成整数来记录某一状态是否访问过。 有一结论，如果列数为奇数，那么初始状态和最终状态的逆序对数奇偶性相同。 AC代码 // 调...
POJ1077 Eight —— 反向BFS
A man can be destroyed, but not defeated.
09-05 736
主页面：http://write.blog.csdn.net/postedit/77825569 代码一：以数组充当队列，利用结构体中的pre追溯上一个状态在数组（队列）中的下标： #include #include #include #include #include #include #include #include #include #incl
解密15拼图：从POJ 1077 Eight探讨解题策略
"这是一个关于ACM竞赛中的Poj 1077 Eight问题的讨论，主要涉及15拼图游戏的解决策略和算法。" 在计算机科学领域，特别是算法设计和编程竞赛（如ACM）中，解决问题的能力是至关重要的。Poj 1077 Eight是一个基于15...
POJ1077
severus_vinegar的专栏
03-19 471
昨天练习的题目，前天才学A*，昨天敲错了，保存的不是状态真不知道自己怎么想的。 这道题还有一个地方就是需要康拓展开，看了别人的解释才明白，后来发现这道题可以直接写BFS，害得我昨天一直在纠结A*。 今天将普通BFS写一下，然后再写了一下A*一个70ms，一个35ms也没快多少。自己写的A*有一个问题就是当需要存储的状态已经在OPEN里面了，但是如何更新.我直接省略了这一步。觉得将它们全部放入让
poj1077(A*,IDA*)
ysjjovo的专栏
08-03 1986
1.资料请参考刘汝佳的黑书，组合数学。 2.A*实现（先贴代码，以后再补） #include #include #include #include #include using namespace std; int p[9]= {1,1,2,6,24,120,720
POJ1077(8数码问题)
qust1508060414的博客
08-24 465
题目链接：http://poj.org/problem?id=1077 这个用BFS、双向BFS、Astar都能解决，这里先用双向BFS来做。 因为要输出路径，多以不能直接用STL中的queue容器，不然出队后就找不到了，所以就自己封装了一个队列，用数组模拟的，还增加了输出路径的功能，留下来当做模板来用。 这里让空格走四个方向，把状态按照题目给的方式排成一列，用康拓展开来记录状态，用两个队列
Poj1077(bfs,排列散列)
Feynman1999的博客
04-26 333
problem 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 x 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 5 6 7 8 5 6 7 8 5 6 7 8 5 6 7 8 9 x 10 12 9 10...
poj-1077（bfs+康托展开）
weixin_45732455的博客
03-18 326
原题链接http://poj.org/problem?id=1077 大概题意就是把你输入的九宫格变成目标九宫格（大概小时候都玩过这种游戏，复原九宫格），然后输出每次移动的方向。不了解康托展开的可以百度一下，对全排列的判重很有用。提交的时候c++一直超时，改来改去还是不行，改成g++就ac了，郁闷。 代码如下（附有题解） #include<iostream> #include<q...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值