hdu1043 Eight（A*/双向BFS/单项BFS打表+康托展开）

最新推荐文章于 2022-12-31 23:45:00 发布
最新推荐文章于 2022-12-31 23:45:00 发布
阅读量2.1k 收藏 8
点赞数 4
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengxingyuanlove/article/details/49049777
版权

题目链接：点击打开链接

题意描述：经典八数码问题，给定八数码的初始序列，求经过u、r、l、d四种操作到达1 2 3 4 5 6 7 8 x的状态，打印出操作序列？


解题思路：A*/双向BFS/单项BFS打表+康托展开   202msAC

方法一：BFS逆向打表+康托展开：从1 2 3 4 5 6 7 8 x逆向扩展，记录哪些状态可以到达，以及到达给状态操作

代码：

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int Cantor(int *s,int n){///康托展开
    int i,j,num,temp;
    num=0;
    for(i=0;i<n;++i){
        temp=0;
        for(j=i+1;j<n;++j){
            if(s[j]<s[i])
                temp++;
        }
        num+=fac[n-1-i]*temp;
    }
    return num;
}
void CantorReverse(int index,int *t,int n){///逆康托展开
    index--;///注意index表示第几个，index>=1
    int i,j;
    bool hash[10]={0};
    for(i=0;i<n;++i){
        int tmp=index/fac[n-1-i];
        for(j=0;j<=tmp;++j)
            if(hash[j]) tmp++;
        t[i]=tmp+1;
        hash[tmp]=1;
        index%=fac[n-1-i];
    }
    return;
}
bool can[362880];
char ans[362880][42];
int target[]={1,2,3,4,5,6,7,8,0};
int tt[9];
struct node{
    int key,x,y,tol;
    node(int _key,int _x,int _y,int _tol):key(_key),x(_x),y(_y),tol(_tol){}
};
queue<node> q;
int maxtol;
void bfs(){
    mem(can,false);
    while(!q.empty()) q.pop();
    int tkey=Cantor(target,9);
    can[tkey]=true;
    ans[tkey][0]='\0';
    q.push(node(tkey,2,2,0));
    while(!q.empty()){
        node tmp=q.front();q.pop();
        CantorReverse(tmp.key+1,tt,9);
        int x=tmp.x,y=tmp.y;
        if(x>=1){
            swap(tt[x*3+y],tt[(x-1)*3+y]);
            tkey=Cantor(tt,9);
            if(!can[tkey]){
                q.push(node(tkey,x-1,y,tmp.tol+1));
                can[tkey]=true;
                for(int i=0;i<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='d';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[(x-1)*3+y]);
        }
        if(y>=1){
            swap(tt[x*3+y],tt[x*3+y-1]);
            tkey=Cantor(tt,9);
            if(!can[tkey]) {
                q.push(node(tkey,x,y-1,tmp.tol+1));
                can[tkey]=true;
                for(int i=0;i<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='r';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[x*3+y-1]);
        }
        if(x<=1){
            swap(tt[x*3+y],tt[(x+1)*3+y]);
            tkey=Cantor(tt,9);
            if(!can[tkey]){
                q.push(node(tkey,x+1,y,tmp.tol+1));can[tkey]=true;
                for(int i=0;i<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='u';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[(x+1)*3+y]);
        }
        if(y<=1){
            swap(tt[x*3+y],tt[x*3+y+1]);
            tkey=Cantor(tt,9);
            if(!can[tkey]) {
                q.push(node(tkey,x,y+1,tmp.tol+1));can[tkey]=true;
                for(int i=0;i<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='l';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[x*3+y+1]);
        }
    }
}
int d[9];
void solve(){
    int tkey=Cantor(d,9);
    if(!can[tkey]){printf("unsolvable\n");return;}
    int len=strlen(ans[tkey]);
    for(int i=len-1;i>=0;--i)
        printf("%c",ans[tkey][i]);
    printf("\n");
}
char op[3];
int main(){
    bfs();
    while(scanf("%s",op)!=EOF){
        int i;
        for(i=0;i<=7;++i){
            if(op[0]=='x') d[i]=0;
            else d[i]=op[0]-'0';
            scanf("%s",op);
        }
        if(op[0]=='x') d[i]=0;
        else d[i]=op[0]-'0';
        solve();
    }
    return 0;
}

方法二：A*（h（x）：曼哈顿距离）+奇偶剪枝（逆序数）+康拓展开 560ms

分析：

1、首先移动x时序列（把x除外）的逆序数奇偶性不会发生变化，左右移动序列不变，上下移动每次某个数会向前移动两位或向后移动两位逆序数+2，所以奇偶性不变

2、给定一个序列我们可以发现要到达目标序列：1 2 3 4 5 6 7 8 x至少需要的距离为当前序列每个数移动到目标序列中该数的位置的步数之和，故可以以此作为估计函数

3、判断是否重复出现可以使用康拓展开

代码：

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <cmath>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int nextx[]={-1,0,1,0},nexty[]={0,1,0,-1};
char nextop[]={'u','r','d','l'};
int tx[]={2,0,0,0,1,1,1,2,2},ty[]={2,0,1,2,0,1,2,0,1};
int Cantor(int *s,int n){///康托展开
    int i,j,num,temp;
    num=0;
    for(i=0;i<n;++i){
        temp=0;
        for(j=i+1;j<n;++j){
            if(s[j]<s[i])
                temp++;
        }
        num+=fac[n-1-i]*temp;
    }
    return num;
}
bool can[362880];
int pre[362880];
char charop[362880];
int tt[9];
struct node{
    int xx[9];
    int key,x,y;
    int d,h;
    node(){}
    node(int _key,int _x,int _y,int _d,int _h):key(_key),x(_x),y(_y),d(_d),h(_h){}
    bool operator<(const node& b)const{
        return (d+h)>(b.d+b.h);
    }
};
int geth(int* tt){
    int h=0;
    for(int i=0;i<9;++i){
        if(tt[i])
            h+=abs(i/3-tx[tt[i]])+abs(i%3-ty[tt[i]]);
    }
    return h;
}
int target;
char ans[100];
int anstol;
int d[9],tg[]={1,2,3,4,5,6,7,8,0};
void bfs(int s,int x,int y){
    mem(can,false);
    priority_queue<node> q;
    can[s]=true;
    pre[s]=-1;
    node tmp(s,x,y,0,geth(d));
    for(int i=0;i<9;++i) tmp.xx[i]=d[i];
    q.push(tmp);
    while(!q.empty()){
        tmp=q.top();q.pop();
        if(tmp.key==target){
            anstol=0;
            int key=target;
            while(pre[key]!=-1){
                ans[anstol++]=charop[key];
                key=pre[key];
            }
            for(int i=anstol-1;i>=0;--i)
                printf("%c",ans[i]);
            printf("\n");
            return;
        }
        node v;
        for(int i=0;i<4;++i){
            v.x=tmp.x+nextx[i],v.y=tmp.y+nexty[i];
            for(int i=0;i<9;++i) v.xx[i]=tmp.xx[i];
            if(v.x>=0&&v.x<=2&&v.y>=0&&v.y<=2){
                swap(v.xx[tmp.x*3+tmp.y],v.xx[v.x*3+v.y]);
                v.key=Cantor(v.xx,9);
                if(!can[v.key]){
                    v.d=tmp.d+1;
                    v.h=geth(v.xx);
                    pre[v.key]=tmp.key;
                    charop[v.key]=nextop[i];
                    can[v.key]=true;
                    q.push(v);
                }
            }
        }
    }
    printf("unsolvable\n");
}
bool ischeck(){
    int flag=0;
    for(int i=0;i<9;++i){
        if(d[i]==0) continue;
        for(int j=i+1;j<9;++j){
            if(d[j]&&d[i]>d[j]) flag++;
        }
    }
    if(flag%2) return true;
    return false;
}
char op[3];
int main(){
    target=Cantor(tg,9);
    while(scanf("%s",op)!=EOF){
        int i,x,y;
        for(i=0;i<=7;++i){
            if(op[0]=='x') {d[i]=0;x=i/3;y=i%3;}
            else d[i]=op[0]-'0';
            scanf("%s",op);
        }
        if(op[0]=='x') {d[i]=0;x=i/3;y=i%3;}
        else d[i]=op[0]-'0';
        if(ischeck()) {printf("unsolvable\n");continue;}
        bfs(Cantor(d,9),x,y);
    }
    return 0;
}

方法三：双向BFS+奇偶剪枝+康托展开 546ms

代码：

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <cmath>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int nextx[]={-1,0,1,0},nexty[]={0,1,0,-1};
char preop[]={'u','r','d','l'};
char nextop[]={'d','l','u','r'};
int tx[]={2,0,0,0,1,1,1,2,2},ty[]={2,0,1,2,0,1,2,0,1};
int Cantor(int *s,int n){///康托展开
    int i,j,num,temp;
    num=0;
    for(i=0;i<n;++i){
        temp=0;
        for(j=i+1;j<n;++j){
            if(s[j]<s[i])
                temp++;
        }
        num+=fac[n-1-i]*temp;
    }
    return num;
}
bool can1[362880],can2[362880];
int pre[362880],nexts[362880];
char savepop[362880],savenop[362880];
struct node{
    int tt[9],key;
    int x,y;
    int h;///以扩展深度选择扩展那个队列（扩展深度浅的，性能略好），也可以队列内元素的多少为依据（扩展少的）
    node(){}
};
int geth(int* tt){
    int h=0;
    for(int i=0;i<9;++i){
        if(tt[i])
            h+=abs(i/3-tx[tt[i]])+abs(i%3-ty[tt[i]]);
    }
    return h;
}
char ans[100];
int anstol;
int s[9],t[]={1,2,3,4,5,6,7,8,0};
int source,target;
void print(int key){
    int tkey=key;
    anstol=0;
    while(pre[tkey]!=-1){
        ans[anstol++]=savepop[tkey];
        tkey=pre[tkey];
    }
    for(int i=anstol-1;i>=0;--i)
        printf("%c",ans[i]);
    tkey=key;
    while(nexts[tkey]!=-1){
        printf("%c",savenop[tkey]);
        tkey=nexts[tkey];
    }
    printf("\n");
    return;
}
void bfs(int x,int y){
    queue<node> q1,q2;
    mem(can1,false);mem(can2,false);
    can1[source]=true;
    can2[target]=true;
    pre[source]=-1;
    nexts[target]=-1;
    node tmp;
    tmp.key=source;tmp.x=x;tmp.y=y;tmp.h=0;
    for(int i=0;i<9;++i) tmp.tt[i]=s[i];
    q1.push(tmp);
    tmp.key=target;tmp.x=2;tmp.y=2;tmp.h=0;
    for(int i=0;i<9;++i) tmp.tt[i]=t[i];
    q2.push(tmp);
    int flag;
    while(!q1.empty()||!q2.empty()){
        if(!q1.empty()&&(q2.empty()||(q1.front().h<q2.front().h))){
            flag=1;tmp=q1.front();q1.pop();
            if(can2[tmp.key]) {print(tmp.key);return;}
        }
        else{
            flag=2;tmp=q2.front();q2.pop();
            if(can1[tmp.key]) {print(tmp.key);return;}
        }
        node v;
        for(int i=0;i<4;++i){
            v.x=tmp.x+nextx[i],v.y=tmp.y+nexty[i];
            for(int j=0;j<9;++j) v.tt[j]=tmp.tt[j];
            if(v.x>=0&&v.x<=2&&v.y>=0&&v.y<=2){
                swap(v.tt[tmp.x*3+tmp.y],v.tt[v.x*3+v.y]);
                v.key=Cantor(v.tt,9);
                v.h=tmp.h+1;
                if(flag==1&&!can1[v.key]){
                    pre[v.key]=tmp.key;
                    savepop[v.key]=preop[i];
                    if(can2[v.key]) {print(v.key);return;}
                    can1[v.key]=true;
                    q1.push(v);
                }
                else if(flag==2&&!can2[v.key]){
                    nexts[v.key]=tmp.key;
                    savenop[v.key]=nextop[i];
                    if(can1[v.key]) {print(v.key);return;}
                    can2[v.key]=true;
                    q2.push(v);
                }
            }
        }
    }
    printf("unsolvable\n");
}
bool ischeck(){
    int flag=0;
    for(int i=0;i<9;++i){
        if(s[i]==0) continue;
        for(int j=i+1;j<9;++j){
            if(s[j]&&s[i]>s[j]) flag++;
        }
    }
    if(flag%2) return true;
    return false;
}
char op[3];
int main(){
    target=Cantor(t,9);
    while(scanf("%s",op)!=EOF){
        int i,x,y;
        for(i=0;i<=7;++i){
            if(op[0]=='x') {s[i]=0;x=i/3;y=i%3;}
            else s[i]=op[0]-'0';
            scanf("%s",op);
        }
        if(op[0]=='x') {s[i]=0;x=i/3;y=i%3;}
        else s[i]=op[0]-'0';
        if(ischeck()) {printf("unsolvable\n");continue;}
        source=Cantor(s,9);
        bfs(x,y);
    }
    return 0;
}


Think_Idea
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 1043（八数码问题）
Rookie21的博客
01-14 433
一道八数码的题目，这里介绍其中一个解法：哈希+打表（比较水但简单的解法）。        首先，题目解法是将9个数字（'x'看成数字9）的每一种排列看成一种状态，则共有9！种不同的状态。我们从结果状态（1,2,3,4,5,6,7,8,9,）开始bfs搜索，每到达一个状态就将这个状态标记上（一是标记这个状态可以到达结果，二是标记访问了这个状态，防止重复访问，ps:利用一个flag数组来进行标记），
C++迭代加深搜索及其例题讲解—————Addition Chains
C2020lax的博客
04-25 1405
前言： 学习算法时，一个关键的问题是什么时候来使用它。在一些搜索问题中，使用普通的DFS可能会让你把时间浪费在深度非常大而且答案不是最优的搜索过程上，甚至有的时候DFS搜索的深度是无穷的，而BFS虽说理论上可以避免这种情况，却又无法满足题目的某些需求，或者无法实现。仔细思考一下这个例子，它有着两个特征：一是它是个最优解问题，二是最优的答案深度最小，如右图： 但是我们的答案有三个，若我们要a...
迭代加深搜索
多看多听多总结
10-12 741
每次限制搜索深度的深度优先搜索。本质还是深度优先搜索，只不过在搜索的同时带上了一个深度d，当d达到设定的深度时就返回，一般用于最优解。如果一次搜索没有找到合法的解，就让设定的深度加1，重新从要开始。因为BFS的基础是一个队列，队列的空间复杂度很大，当状态比较多或者单个状态比较大时，使用队列的BFS就显出了劣势。事实上，迭代加深类似于用DFS方式实现的BFS，它的空间复杂度相对较小。 当搜索树的分支比较多时，每增加一层的搜索复杂度会出现指数级爆炸式增长，这时前面重复进行的部分所带来的复杂度几乎可以忽略，这也
A - Eight HDU - 1043（A*算法、双向bfs）
做一只熊猫不好吗？
07-06 261
A - Eight HDU - 1043（A*算法、双向bfs） 题意 给我们 8个数（1,23…）和一个字母x组成的一个序列，让我们通过 上下左右移动x操作，把这个序列变成：1 2 3 4 5 6 7 8 x 思路一 双向bfs 我们先考虑，什么是 双向bfs ？，简单的说就是，从起点、终点两个方向开始 bfs搜索， 这个算法的实现是通过 两个队列 q1、q2q1、q2q1、q2, 我们分别把起点、终点的搜索状态 压入q1、q2q1、q2q1、q2, 再通过 vis1[&nbsp
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
八数码A*算法 HDU 1043
07-26
八数码的A*算法~不是很高效，但是很适合刚刚学这个算法的朋友们
HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，...来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得。 大佬勿入！
hdu 1753 大明A+B
05-26
现在，给你两个正的小数A和B，你的任务是代表大明计算出A+B的值。 Input 本题目包含多组测试数据，请处理到文件结束。 每一组测试数据在一行里面包含两个长度不大于400的正小数A和B。 Output 请在一行里面...
迭代加深搜索(埃及分数)
最新发布
m0_61948547的博客
12-31 292
给定一个分数，如7/8，我们可以把它表示为1/2 + 1/3 +1/24，埃及分数问题即把一个真分数表示为最少的埃及分数之和的形式。表示为最少的埃及分数之和要求其末尾的埃及分数分母尽可能达到最小，即埃及分数尽可能大。埃及分数是指分子是1的分数，也叫单位分数。古代埃及人在进行分数运算时。只使用分子是1的分数。因此这种分数也叫做埃及分数，或者叫单分子分数。设输入为a/b，b/a所得整数部分为c,余数部分为d,则。设e等于c+1,1/e为当前最大埃及分数。
hdu1043
思维缜密的博客
04-12 829
8数码，无解情况为逆序数为奇数，用康托展开压缩成一个int来判重 这个是多组输入 所以我们不能来一组搜一次 这里给出bfs和A* A*的话，你可以使用曼哈顿距离，当然，由于不用最少步数，可以用3倍曼哈顿距离加速 IDA*的话用曼哈顿距离就好了 bfs 我们从终点反向搜索所有的点，然后来一组搜一组 #include<iostream> #include<cstdi...
搜索进阶-迭代加深搜索
热门推荐
hzaukotete的博客
07-26 1万+
我个人对这个搜索的理解就是以BFS的思想写DFS。 具体来说就是，首先深度优先搜索k层，若没有找到可行解，再深度优先搜索k+1层，直到找到可行解为止。由于深度是从小到大逐渐增大的，所以当搜索到结果时可以保证搜索深度是最小的。这也是迭代加深搜索在一部分情况下可以代替广度优先搜索的原（还比广搜省空间）。   前提： 题目一定要有解，否则会无限循环下去。   好处： 1.时间复杂度只比BF...
Eight hdu 1043 八数码问题 双搜
weixin_33676492的博客
07-12 268
Eight Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 11226Accepted Submission(s): 3013Special Judge Problem Description The 15-puzzle h...
HDU - 1043 (Eight)
Joker & Liar的博客
03-02 230
题意：八数码问题，多组输入，给出路径； 分析：因为多组输入而且要给出路径，所以得预先反向BFS把所有结果打表，不然会T ，然后hash就用康托展开； 代码： #include<queue> #include<cstdio> #include<string> #include<cstring> #include<iostrea...
HDU 1043 Eight(经典八数码)(BFS+STL)
Ephemeral
10-18 380
EightTime Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 26254    Accepted Submission(s): 6980Special JudgeProblem Description The 15-puzzle has bee
HDU - 1043 Eight(八数码+康拓展开式+BFS暴力打表)
x__1998的博客
04-15 358
EightTime Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Special JudgeProblem DescriptionThe 15-puzzle has been around for over 100 years; even if you don't know it by ...
"浅谈Hash表构造方法——HDUACM2010版_14
表简介——函数构造-HDUACM2010版) Hash表是一种数据结构，它可以快速地在大量数据中查找某个特定的元素。而构造Hash表的关键在于构造Hash函数，以便能够将元素存储到相应的位置上。在构造Hash函数时，最常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值