POJ 1077 八数码问题 练习搜索

最新推荐文章于 2021-10-30 09:34:58 发布
最新推荐文章于 2021-10-30 09:34:58 发布
阅读量591 收藏
点赞数
分类专栏： ACM 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012935901/article/details/21122239
版权
ACM 同时被 2 个专栏收录
142 篇文章 0 订阅
订阅专栏
搜索
15 篇文章 0 订阅
订阅专栏

简单bfs+康托展开判重，足以过掉。

一会再写 双向 bfs 还有 A* 和 IDA *

#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <map>
#include <vector>
#include <cmath>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <fstream>
#include <stack>
using namespace std;

#define READ freopen("acm.in","r",stdin)
#define ll long long
#define PII pair<int,int>
#define PDI pair<double,int>
#define PDD pair<double,double>
#define MII map<int,int>::iterator 
#define fst first
#define sec second
#define MS(x,d) memset(x,d,sizeof(x))
#define INF 0x3f3f3f3f
#define ALL(x) x.begin(),x.end()
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define MAX 500000
#define ROOT 0,n-1,1
#define PB push_back
#define FOR(a,b,c) for(int a=b;a<c;a++)
#define MOD 706679
#define keyTree (ch[ ch[root][1] ][0])

int init;
// r l u d
int dir[4][2]={0,1,0,-1,-1,0,1,0};
int fac[100];
struct P
{
    int s;
    int d;
};
int used[500000];
P pre[500000];
int cantor(int a)
{
    int num[20];
    int res=0;
    int used[20];
    MS(used,0);
    for(int i=9;i>=1;i--)
    {
        int cnt=0;
        int t=a%10;a/=10;
        used[t]=1;
        for(int j=0;j<t;j++)
            if(!used[j])
                cnt++;
        res+=cnt*fac[i-1];
    }
    return res;
}
int end;
int compose(int t[])
{
    int res=0;
    for(int i=0;i<9;i++)
    {
        res=res*10+t[i];
    }
    return res;
}
bool bfs()
{
    MS(used,0);
    queue<int> q;
    q.push(init);
    used[cantor(init)]=1;
    while(!q.empty())
    {
        int s=q.front();
        q.pop();
        if(s==end)
            return true;
        int tmp=s;
        int state[15];
        for(int i=8;i>=0;i--)
        {
            state[i]=tmp%10;
            tmp/=10;
        }
        int x,y;
        for(int i=0;i<9;i++)
            if(state[i]==0)
            {
                x=i/3;
                y=i%3;
            }
        for(int i=0;i<4;i++)
        {
            int tx=x+dir[i][0];
            int ty=y+dir[i][1];
            int ts[15];
            for(int j=0;j<9;j++)
                ts[j]=state[j];
            if(tx>=0&&tx<3&&ty>=0&&ty<3)
            {
                swap(ts[x*3+y],ts[tx*3+ty]);
                int curs=compose(ts);
                int hash=cantor(curs);
                if(!used[hash])
                {
                    q.push(curs);
                    used[hash]=1;
                    pre[hash]=(P){s,i};
                }
            }
        }
    }
    return false;
}

int main()
{
    READ;
    fac[0]=1;
    for(int i=1;i<=10;i++)
        fac[i]=fac[i-1]*i;
    for(int i=1;i<9;i++)
        end=end*10+i;
    end*=10;
    char t[3];
    while(scanf("%s",t)!=EOF)
    {
        if(t[0]!='x')
            init=t[0]-'0';
        for(int i=0;i<8;i++)
        {
            scanf("%s",t);
            if(t[0]!='x')
                init=init*10+t[0]-'0';
            else
                init=init*10;
        }
        if(bfs())
        {
            stack<int> S;
            for(int s=end;s!=init;s=pre[cantor(s)].s)
                S.push(pre[cantor(s)].d);
            while(!S.empty())
            {
                int d=S.top();S.pop();
                switch(d)
                {
                    case 0:
                        cout<<'r';
                        break;
                    case 1:
                        cout<<'l';
                        break;
                    case 2:
                        cout<<'u';
                        break;
                    case 3:
                        cout<<'d';
                        break;
                }
            }
            cout<<endl;
        }
        else
        {
            puts("unsolvable");
        }
    }
    return 0;
}

A* 

#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <map>
#include <vector>
#include <cmath>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <fstream>
#include <stack>
using namespace std;

#define READ freopen("acm.in","r",stdin)
#define ll long long
#define PII pair<int,int>
#define PDI pair<double,int>
#define PDD pair<double,double>
#define MII map<int,int>::iterator 
#define fst first
#define sec second
#define MS(x,d) memset(x,d,sizeof(x))
#define INF 0x3f3f3f3f
#define ALL(x) x.begin(),x.end()
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define MAX 500000
#define ROOT 0,n-1,1
#define PB push_back
#define FOR(a,b,c) for(int a=b;a<c;a++)
#define MOD 706679
#define keyTree (ch[ ch[root][1] ][0])

int init;
// r l u d
int dir[4][2]={0,1,0,-1,-1,0,1,0};
int fac[100];
struct P
{
    int s;
    int d;
};
struct node
{
    int s;
    int G;
    int H;
    bool operator < (const node &o) const
    {
        return (G+H)>(o.G+o.H);
    }
};
int used[500000];
P pre[500000];
int cantor(int a)
{
    int num[20];
    int res=0;
    int used[20];
    MS(used,0);
    for(int i=9;i>=1;i--)
    {
        int cnt=0;
        int t=a%10;a/=10;
        used[t]=1;
        for(int j=0;j<t;j++)
            if(!used[j])
                cnt++;
        res+=cnt*fac[i-1];
    }
    return res;
}
int rev(int a)
{
    int res=0;
    int used[20];
    for(int i=0;i<9;i++)
    {
        int t=a%10;a/=10;
        used[t]=1;
        for(int i=0;i<t;i++)
            if(used[i])
                res++;
    }
    return res;
}
int end;
int compose(int t[])
{
    int res=0;
    for(int i=0;i<9;i++)
    {
        res=res*10+t[i];
    }
    return res;
}
bool bfs()
{
    fill(used,used+500000,INF);
    //queue<int> q;
    priority_queue<node> q;
    q.push((node){init,0,0});
    used[cantor(init)]=0;
    while(!q.empty())
    {
        node tn=q.top();
        int pahash=cantor(tn.s);
        int s=tn.s;
        q.pop();
        if(s==end)
            return true;
        int tmp=s;
        int state[15];
        for(int i=8;i>=0;i--)
        {
            state[i]=tmp%10;
            tmp/=10;
        }
        int x,y;
        for(int i=0;i<9;i++)
            if(state[i]==0)
            {
                x=i/3;
                y=i%3;
            }
        for(int i=0;i<4;i++)
        {
            int tx=x+dir[i][0];
            int ty=y+dir[i][1];
            int ts[15];
            for(int j=0;j<9;j++)
                ts[j]=state[j];
            if(tx>=0&&tx<3&&ty>=0&&ty<3)
            {
                swap(ts[x*3+y],ts[tx*3+ty]);
                int curs=compose(ts);
                int hash=cantor(curs);
                if(used[hash]>used[pahash]+1)
                {
                    q.push((node){curs,used[pahash]+1,rev(curs)});
                    used[hash]=used[pahash]+1;
                    pre[hash]=(P){s,i};
                }
            }
        }
    }
    return false;
}

int main()
{
    READ;
    fac[0]=1;
    for(int i=1;i<=10;i++)
        fac[i]=fac[i-1]*i;
    for(int i=1;i<9;i++)
        end=end*10+i;
    end*=10;
    char t[3];
    while(scanf("%s",t)!=EOF)
    {
        if(t[0]!='x')
            init=t[0]-'0';
        for(int i=0;i<8;i++)
        {
            scanf("%s",t);
            if(t[0]!='x')
                init=init*10+t[0]-'0';
            else
                init=init*10;
        }
        if(bfs())
        {
            stack<int> S;
            for(int s=end;s!=init;s=pre[cantor(s)].s)
                S.push(pre[cantor(s)].d);
            while(!S.empty())
            {
                int d=S.top();S.pop();
                switch(d)
                {
                    case 0:
                        cout<<'r';
                        break;
                    case 1:
                        cout<<'l';
                        break;
                    case 2:
                        cout<<'u';
                        break;
                    case 3:
                        cout<<'d';
                        break;
                }
            }
            cout<<endl;
        }
        else
        {
            puts("unsolvable");
        }
    }
    return 0;
}


Lei2015_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ_3131.zip_POJ 八数码_poj
09-20
POJ 3131 双向BFS解立体八数码问题
POJ1077八数码
loveSiri的博客
03-03 1014
POJ1077:八数码问题(Eight) POJ1077查看 文章目录POJ1077:八数码问题(Eight)@[toc]**解题思路**基础知识铺垫广度优先搜索BFS+康托展开广度优先搜索BFS+set二分查找双向广搜DBFS+set二分查找启发式算法+堆+普通标记数组更多策略 解题思路 求步数最少的解时候用广搜 状态的表示问题 若以字符串的形式表示，需要10字节，且检查是否达到目标状...
POJ 1077 八数码 三种解法
lvxin1204的博客
05-31 5056
POJ 1077 Eight题目链接：http://poj.org/problem?id=1077
poj 1077(八数码)
weixin_30517001的博客
04-14 64
八数码问题有多种解法，本题解采用的是双向搜索 View Code 1 #include<iostream> 2 #include<map> 3 #include<string> 4 #include<queue> 5 #include<stdio.h> 6 #include<strin...
poj 1077 八数码
weixin_30399055的博客
03-16 41
1 #include<iostream> 2 #include<queue> 3 #include<algorithm> 4 #include<string> 5 #include<cstring> 6 #include<cstdio> 7 //正向广度搜索 8 //把“x...
poj-1077 八数码 【a*】
a915800048的专栏
08-22 530
状态总数是9! = 362880 种，不算太多，可以满足广搜和A*对于空间的需求。 假如把x看做0。最大为876543210没超过Int的存储范围，所以用一个int值来表示其平面状态。  #include #include #include #include #include #define keyMax 999983 #define target 123456780 using n
POJ 1077 算法
08-09
关于C++ 算法 北大网站POJ 八数码问题
poj 1077 Eight.md
11-17
poj 1077 Eight.md
pku_poj_2187.rar_poj 2187_凸包问题
09-14
O(nlogn)凸包问题 poj2187
西工大C语言POJ习题答案.docx
11-15
西工大C语言POJ习题答案.docx
POJ1077(经典的八数码问题)
飞翔的小鸟
08-05 3666
很经典的八数码问题，可以用单向广度优先搜索、双向广度优先搜索、A*算法、IDA算法解。 用了双向广度优先搜索和A*算法解，在用A*算法时，纠结了好几天，后来在网上看了一份博客才发现自己错在哪。之后解出来了。虽然做这题时很纠结，不过收获真的很大，痛而快乐着………… 下面贴出用双向广度优先搜索和A*算法做的代码   //A*算法 #include #include #include
poj-1077（bfs+康托展开）
weixin_45732455的博客
03-18 292
原题链接http://poj.org/problem?id=1077 大概题意就是把你输入的九宫格变成目标九宫格（大概小时候都玩过这种游戏，复原九宫格），然后输出每次移动的方向。不了解康托展开的可以百度一下，对全排列的判重很有用。提交的时候c++一直超时，改来改去还是不行，改成g++就ac了，郁闷。 代码如下（附有题解） #include<iostream> #include<q...
poj1077
weixinding的专栏
01-15 1752
【题意】 经典的八数码问题。 描述了一个3*3的格子，每个格子里有一个数，还有一个空位， 每次操作可以将空位跟周围的格子里的数交换，问最少多少次操作可以使方格变为 1 2 3 4 5 6 7 8 x 有解打出最少的操作序列 无解打unsolvable 【输入】 一行，表示格子里的数 【输出】 有解打出最少的操作序列 无解打unsolvable 启发式
poj 1077 Eight
zjsru_Beginner的博客
10-30 389
题目： 是一道经典的八数码问题。将一个3×3的矩阵，通过每次和四周的数字进行互换，最终达到目标状态。其中用字母“l”表示相左移动，“u”表示向上，“r”表示向右，“d”表示向下，最后结果，输出移动的字母。 样例： 目标位置是 初始位置是： 为了从初始位置到达目标位置，需要先将x与5换位置，再与6换位置，也就是先...
POJ 1077 Eight A*算法 八数码问题
mimo9527的专栏
02-26 1400
可以使用A*算法解决。启发函数f(n)=g(n)+h(n)，h(n)=所有棋子到其目标位置的距离和*K，也就是曼哈顿距离*K。经过验证，k=1时会超出POJ的时限，k=4时最快，但K=4得到的结果其实不能最短路径，如下面例子：8 6 7 2 5 4 3 x 1K=1:  ruuldlurddlurrulldrdruldlururddK=2:  urulldrrdluulddruruldldrruldluurrddK=4：ruulddrulldruldrrululddruurddluruldlurrddluu
POJ 1077 Eight A*算法求解
正月看雪花的博客
02-01 3382
题目描述         在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。 在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。 我们的目的是通过交换，使得网格变为如下排列（称为正确排列）： 例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交...
北大 算法基础 八数码 POJ1077
ywqzj的博客
04-02 131
练习代码 : #include<iostream> #include<bitset> using namespace std; int goalStatus;//目标状态 bitset<362880> Flags; const int MAXS = 370000; char result[MAXS];//移动的过程 struct Node { int status;//排列序号 int father;//父序号 char move;//移动到当前序号的动作 N
poj 1077 解题报告
李世操的空间
02-27 499
最近学人工智能，要学A*算法，就重新做这道题经典的8数码问题，传说不做这道题人生不完整呢我之前是用的广搜暴力搞的，不过太慢了，还要说说我的hash方法，我是用康托展开来hash的，这个东西是算一个排列在所有排列大小排多少，比如（1,2,3）有6个排列，321是最大的就是第六个。还有就是康托展开的逆运算，就是知道是第几大的，算出这个排列来； 康托展开： long cantor( int s[]
POJ3984—迷宫问题java
最新发布
11-02
可以使用广度优先搜索或者深度优先搜索算法来解决这个问题。 下面是一个使用广度优先搜索算法的Java代码示例： ```java import java.util.*; public class Main { static int[][] maze = new int[5][5]; // 迷宫...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值