八数码A*【POJ-1077 HDU-1043】

最新推荐文章于 2019-10-04 11:37:33 发布
最新推荐文章于 2019-10-04 11:37:33 发布
阅读量725 收藏 1
点赞数
分类专栏： 搜索 文章标签： BFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012469987/article/details/38086919
版权

题目：http://poj.org/problem?id=1077

用数字0代表X，放在数组里，康拓展开求状态值肯定不重叠，因为本身就是排列

A*：估价函数为每个数到它该在位置（目标状态）的距离之和

312  ->123
465  ->456
087  ->780

估价值：

2 + 1 + 1 + 0 + 1 + 1 + 2+ 0 + 2 = 10

值越小，说明该状态离目标状态最近。虽然这个启发函数不完美，误判的情况很多，但是它能提高搜索效率

此外先不考虑X，求1-8的逆序数，如果逆序数是奇数就不可解，因为交换数字，不改变逆序数的奇偶性，而最终状态逆序数是0（偶数）。


自己的证明：
空格与左右棋子交换不会改变棋子数列的逆序数，因为数列并没有改变。


1 5 4

3 2 6

7 8 X

假设交换X和6，则6对7，8的逆序数各加1，加了偶数个（X的逆序数是不考虑的）。同理，X跟下面的交换逆序数-2，逆序数是偶数的依旧是偶数，不改变逆序数的奇偶性。


//POK 0MS   HDU 734MS
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<iostream>
#include<algorithm>
using namespace std;
#define ll long long
#define INF 0x7F7F7F7F
#define eps 10^(-6)
#define MEM(a) memset(a,0,sizeof(a));
#define FOR(i,n) for(int i=0;i<n;i++)
#define FIN freopen("in.txt","r",stdin);
#define FOUT freopen("out.txt","w",stdout);	//右+1,下：+3，上-3，左-1
#define Max 366666
int a[4]={-3,-1,1,3},n,m,visit[Max],tp[Max],s_state;
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
int aim[9];        //aim[i]:目标状态i位置的数
int end_aim;
struct node
{//state为状态值，由康拓展开计算，x为X的位置，pos为被交换数的位置
	int x,state,ss[9],pos;
	int f,g,h;//估价值
	bool operator < (const node &Another)const
	{
	    return f > Another.f;//小值优先
	}
};
struct save
{
	int pre,dir;//方向和父节点
}path[Max];

priority_queue<node> q;

char change(int dir);

int cantor(int s[]) //康拓保存状态
{
	int temp,i,j,res=0;
	for(i = 0; i < 9; i++)
	{
		temp = 0;
		for(j = i + 1; j < 9; j++)
			if(s[j] < s[i])
				temp++;
		res += temp*fac[8-i];
	}
	return res+1;
}

void print1(int state)
{
    int num = 0,i;
    while(state != s_state )
    {
        tp[num++]=change(path[state].dir);
        state=path[state].pre;
    }
    for( i=num-1; i>=0; i--)
        printf("%c",tp[i]);
}

char change(int dir)	//右+1,下：+3，上-3，左-1
{
	if( dir == -3) return 'u';
	if( dir == -1) return 'l';
	if( dir ==  1) return 'r';
	if( dir ==  3) return 'd';
}

int count_h(int cur[])  //该数和它本该在的位置的距离
{
    int dis = 0;
    for(int i = 0; i <= 8; i++)
    {
        if(cur[i] != 0)
            dis += abs(cur[i] - (i+1));
        else
            dis += 9-(i+1);
    }
    return dis;
}

int AStar(int s[])
{
	node t,cur;
	int i,temp,k;
	while(!q.empty()) q.pop();
	memset(visit,0,sizeof(visit));

	for(i = 0; i <= 8; i++)
	{
		t.ss[i] = s[i];
		if(s[i] == 0)
			t.x = i;
	}
	t.state = cantor(t.ss);
	visit[t.state] = 1;
	path[t.state].pre = -1;
    t.f = count_h(s);
	q.push(t);
	s_state = t.state;  //起始状态值，用于打印路径

	while( !q.empty() )
	{
        t = q.top();
        q.pop();
        if( t.state == end_aim )
        {
            print1(t.state);
            putchar('\n');
            return 1;
        }
        for(i = 0; i < 4; i++)
        {
            cur.pos = t.x + a[i];
            if(a[i] == 1 && (t.x+1)%3==0 )
                continue;           //一位数组转行处理
            if(a[i] == -1 && t.x%3==0 )
                continue;
            if( cur.pos >=0 && cur.pos <=8 )
            {
                for(k=0;k<=8;k++)   //copy原状态数字
                    cur.ss[k] = t.ss[k];
                {                    //交换
                    temp = cur.ss[t.x];
                    cur.ss[t.x] = cur.ss[cur.pos];
                    cur.ss[cur.pos] = temp;
                }
                cur.x = cur.pos;
                cur.state = cantor(cur.ss);
                cur.f = count_h(cur.ss);
                if( !visit[cur.state] )
                {
                    path[cur.state].dir = a[i];
                    path[cur.state].pre = t.state;
                    visit[cur.state] = 1;
                    q.push(cur);
                }
            }
		}
	}
	return 0;
}
int check(int s[])  //忽视x，求逆序数
{
    int i,j,cnt=0;
    for(i=0;i<=8;i++)
    {
        if(s[i]==0) continue;
        for(j=0;j<i;j++)
        {
            if(s[j]==0) continue;
            if(s[j]>s[i]) cnt++;
        }
    }
    return cnt;
}
int main()
{
	int i,j,ok,s[10];
    char str[30];
  //  FIN
    for(int i = 0; i < 8; i++)
		aim[i] =  i + 1;
	aim[8] = 0; //目标状态
    end_aim = cantor(aim);

    while(gets(str))
    {
        j=0;
        for(i=0; str[i]; i++)
        {       //X用0代表
            if(str[i] >= '1' && str[i] <= '8')
				s[j++] = str[i]-'0';
            else if(str[i] == 'x') s[j++]=0;
        }
        if(check(s)%2)
             puts("unsolvable");
        else
        {
             ok = AStar(s);
             if(!ok)
                puts("unsolvable");
        }
    }
	return 0;
}



双向BFS(HDU会TLE)

						//	32MS
#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;	//右+1,下：+3，上-3，左-1
#define Max 366666
int a[4]={-3,-1,1,3},n,m,vist1[Max],vist2[Max],tp[Max],	s_state;	
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
typedef struct 
{
	int x,state,ss[9],pos;
}node;

struct save
{
	int pre,dir;
}path1[Max],path2[Max];
queue <node> p,q;
char change(int dir);
char change2(int dir);
int cantor(int s[])
{
	int temp,i,j,res=0;
	for(i=0;i<9;i++)
	{
		temp = 0;
		for(j=i+1;j<9;j++)
			if(s[j] < s[i])
				temp++;
		res+=temp*fac[8-i];
	}
	return res+1;
}

void print1(int state)
{
    int num=0,i;
   while(state != s_state ) 
		tp[num++]=change(path1[state].dir), state=path1[state].pre;
    for( i=num-1; i>=0; i--) printf("%c",tp[i]);
}
void print2(int state)
{
	while(path2[state].pre != -1 )
	{
		printf("%c",change2(path2[state].dir));
		state = path2[state].pre;
	}
}
char change2(int dir)	//右+1,下：+3，上-3，左-1
{
	if( dir == -3) return 'd';
	if( dir == -1) return 'r';
	if( dir ==  1) return 'l';
	if( dir ==  3) return 'u';
}
char change(int dir)	//右+1,下：+3，上-3，左-1
{
	if( dir == -3) return 'u';
	if( dir == -1) return 'l';
	if( dir ==  1) return 'r';
	if( dir ==  3) return 'd';
}
int bfs(int s[])
{ 
	node t,cur;
	int i,temp,k;
	while(!q.empty()) q.pop();
	while(!p.empty()) p.pop();
	memset(vist1,0,sizeof(vist1));
	memset(vist2,0,sizeof(vist2));

	for(i=0;i<=8;i++)
	{
		t.ss[i] = s[i];
		if(s[i] == 0)
			t.x = i;
	}
	t.state = cantor(t.ss);
	vist1[t.state] = 1;	
	path1[t.state].pre = -1;
	q.push(t);	
	s_state = t.state;

	for(i=0;i<8;i++)
		t.ss[i] =  i+1;
	t.ss[8] = 0;
	t.x = 8;
	t.state = cantor(t.ss);
	vist2[t.state] = 1;
	path2[t.state].pre = -1;
	p.push(t);

	while( !q.empty() && !p.empty() )
	{
		if(!q.empty())
		{
			t=q.front();
			q.pop();
			for(i=0;i<4;i++)
			{
				cur.pos = t.x + a[i];
				if(a[i] == 1 && (t.x+1)%3==0 )
					continue;
				if(a[i] == -1 && t.x%3==0 )
					continue;
				if( cur.pos >=0 && cur.pos <=8 )
				{
					for(k=0;k<=8;k++)
						cur.ss[k] = t.ss[k];
					{
						temp = cur.ss[t.x];
						cur.ss[t.x] = cur.ss[cur.pos];
						cur.ss[cur.pos] = temp;
					}
					cur.x = cur.pos;
					cur.state = cantor(cur.ss);
					if( !vist1[cur.state] ) 
					{
						path1[cur.state].dir = a[i];
						path1[cur.state].pre = t.state;
						vist1[cur.state] = 1;	
						q.push(cur);
					}
					if( vist2[cur.state] )
					{
						print1(cur.state);
						print2(cur.state);
						putchar('\n');
						return 1;
					}		
				}
			}
		}
		if(!p.empty())
		{
			t=p.front();
			p.pop();
			for(i=0;i<4;i++)
			{
				cur.pos = t.x + a[i];
				if(a[i] == 1 && (t.x+1)%3==0 )
					continue;
				if(a[i] == -1 && t.x%3==0 )
					continue;
				if( cur.pos >=0 && cur.pos <=8 )
				{
					for(k=0;k<=8;k++)
						cur.ss[k] = t.ss[k];
					{
						temp = cur.ss[t.x];
						cur.ss[t.x] = cur.ss[cur.pos];
						cur.ss[cur.pos] = temp;
					}
					cur.x = cur.pos;
					cur.state = cantor(cur.ss);	
					if( !vist2[cur.state] ) 
					{
						path2[cur.state].dir = a[i];
						path2[cur.state].pre = t.state;	
						vist2[cur.state] = 1;
						p.push(cur);						
					}			
					if( vist1[cur.state] )
					{
						print1(cur.state);
						print2(cur.state);
						putchar('\n');
						return 1;
					}
				}
			}
		}
	}
	return 0;
}

int main()
{
	int i,j,ok,s[10];
    char str[30];
//	freopen("a.txt","r",stdin);
    while(gets(str))
    {
        j=0;
        for(i=0; str[i]; i++)
        {
            if(str[i]>='1'&&str[i]<='8')
				s[j++]=str[i]-'0';
            else if(str[i]=='x') s[j++]=0;
        }
		ok=bfs(s);
        if(!ok) puts("unsolvable");
    }
	return 0;
}


角落的秋天
关注
专栏目录
bfs+hash poj 1077/hdu 1043 八数码问题
Mr.CJ
02-22 1050
Y的，若不吐槽天理不容了。 一看这题，有点不敢做，主要是状态不好记录，以前做迷宫的从来没有将整个状态存入每个结构体的节点中，这对于是否访问过的记录就很耗时，不过这里只是长度为9的数组，转换成字符串也可以理解。然后就开始用上set了，果断就超时了，然后就傻眼了。百度之后发现新大陆，全排列逆序对的东西真是强大，好多hash的喜悦心情让我继续做下去，我~~去，又是TLE，难道是因为我顺便每个节点都保存
搜索专题突破POJ1077 POJ1324 POJ2046 HDU2485 HDU1560 HDU1667 POJ3134 POJ1915 HDU1401 HDU1430 HDU2691
Luowaterbi的博客
08-18 395
POJ1077Eight 八数码问题，就是手机上那个智能拼图的小游戏感觉很小的时候在诺基亚上玩过。只有一个块可以上下左右移动，问能否拼好。 IDA*搜索。估值函数就是目前拼图的曼哈顿距离。这是最理想化的情况，就是只经过曼哈顿距离，所有拼图回到自己位置。因为每次只能改变一个拼图的位置。所以最少就是曼哈顿距离。 估值函数的选取，就是去想最最理想的情况需要多少步达到目标。一般最理想都是实现不了，需...
POJ-1475（A*算法）
还有多远
01-07 1895
题目：http://poj.org/problem?id=1475 一眼看上去就能确定是BFS，但这题和普通寻找终点的BFS不一样，除了自身的位置，状态上还要体现箱子的位置。由于题目要求最少push最少walk，因此可以A*。 一个重要的问题是，搜到了之后如何生成路径，可以这么考虑：A*搜索使得我们到达终点完成任务时，走的路径时最优的，由于状态间是一步转移的，因此上一个状态形成的路径也肯定是最
POJ1077 Eight —— A*算法
alince20008的博客
09-05 151
主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html 关于A*算法：g(n)表示从起点到任意节点n的路径花费，h(n)表示从节点n到目标节点路径花费的估计值（启发值），f(n) = g(n)+h(n)。 A*算法必须满足的条件（能不能满足由所选的h(n)估计方式决定）：每次扩展的节点的 f 值 >= 父节点的 f 值。...
POJ - 1077 简单做法 A*
Tizzi的博客
10-04 506
一、内容 在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。 例如： 1 2 3 X 4 6 7 5 8 在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。 我们的目的是通过交换，使得网格变为如下排列（称为正确排列）： 1 2 3 4 5 6 7 8 X 例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交换成功得到...
POJ1077 Eight A*
Kevin的博客
09-11 397
题目链接 http://poj.org/problem?id=1077 分析 直接用BFS进行状态扩展会超时，需要设计估价函数跑A*算法。 每次只能使一个数位置改变，因此未来的操作次数不会小于每个数当前位置于最终位置的曼哈顿距离之和。 用这个作为估价函数，用康托展开将排列映射成整数来记录某一状态是否访问过。 有一结论，如果列数为奇数，那么初始状态和最终状态的逆序对数奇偶性相同。 AC代码 // 调...
poj2243(A*算法)
无奈滴微笑
04-16 867
A*算法：http://www.gamedev.net/page/resources/_/technical/artificial-intelligence/a-pathfinding-for-beginners-r2003 看起来不错，屌屌的。各种游戏寻路。想到星际争霸，帝国时代那些单位恢宏的寻路方式，不得不点赞啊。 Knight Moves Time Limit:
HDU 1043 Eight poj 1077 （八数码 启发式搜索）
qwesde
08-30 496
题目链接 poj1077 hdu1043使用A*搜索就可以了 A*是bfs的一种优化，使用函数F做为每个节点的访问的优先级hdu的需要先判断是否有解，否则会tle，加上后跑了1000+ms poj的不用判断，也可以ac，跑了40+ms一个状态表示成一维的形式，求出除0之外所有数字的逆序数之和，也就是每个数字前面比它大的数字的个数的和，称为这个状态的逆序。 若两个状态的逆序奇偶性 相同，则可
八数码解题算法与实现解析
在实现八数码问题的解决方案时，我们常常使用四种基本的搜索策略：深度优先搜索（DFS）、广度优先搜索（BFS）、A*搜索和IDA*搜索。每种方法都有其特点，例如DFS能快速找到解但可能不最优，BFS能找到最短路径但效率较...
八数码
Confidence的专栏
03-12 2120
八数码的两种搜索方式详细分析 A* IDA*
POJ 2243 Knight Moves 广搜可直接水，这里用A*搜索
猫ER
06-10 259
题意：一个8 * 8的棋盘从起点跳到终点要走多少步，骑士走“日”。“a5”其中5是行号，a是列号   想法：正常广搜就能过，用A*，G = 走的步数 * 3（也可以直接就等于步数），H = 两点之间的水平距离和垂直距离之和。采用优先队列，将G + H值小的放队列前面。#include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;queue...
学习记录——记忆化搜索 A* POJ2449 Remmarguts' Date
Loi_Seavot的博客
10-07 597
嗯，因为今天考试有个状压搜索可以用A*优化，以前也做过A*的题没有AC，于是今天就打算学一下A*（Astar）……百度第一个文章其实就不错的，地址：戳我 建议大家先去看这篇文章。 那篇文章讲的确实不错，但是例题却是坑了点，曼哈顿距离对于平面图可以卡死，但是好的启发函数对于那个图来说预处理就可以找到最短路了（宽搜），所以文章很好，例题可以考虑换一个~下面讲一些自己的理解：启发式搜索由两部分构成，g
poj1077(A*+康拓展开)
stay_accept的专栏
09-01 854
题意：八数码 链接：点击打开链接 代码： #include &lt;map&gt; #include &lt;set&gt; #include &lt;queue&gt; #include &lt;string&gt; #include &lt;math.h&gt; #include &lt;vector&gt; #include &lt;stdio.h&gt; #include &amp
POJ-1324（A*+状态压缩）
还有多远
09-01 923
一开始用deque保存状态信息，用queue进行BFS，TLE
poj 2243 双向bfs和A*
涛涛不解
05-16 2158
题目大意：就是给你一个起点和一个终点，按骑士的走法，从起点到终点的最少移动多少次 解题思路：水题~~~直接bfs就可以了，没写过双向bfs，这次训练一下，双向bfs就是用两个队列，一个队列保存从起点开始的状态，另一个保存从终点开始向前搜索的状态，双向bfs主要是区分每个格子是从起点开始搜索到的还是从终点开始搜索到的~每个经过的格子结点保存到达该格子经过的步数，这样两边要是相交了相加就是结果 另
HDU 1043 八数码问题 A*搜索
热门推荐
窝不是爱酱,喵~~~~
07-13 1万+
转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents           by---cxlove 第一个A*搜索，A*是一种启发式搜索，g为已花代价，h为估计的剩余代价，而A*是根据f=g+h作为估价函数进行排列，也就是优先选择可能最优的节点进行扩展。 对于八数码问题，以下几个问题需要知道 判断有无解问题：根据逆序数直接判断
POJ2449 Remmarguts' Date K短路模板 【A* + dijkstra】
Tizzi的博客
10-03 662
一、内容 题意：给定一个有向图，求S起点到T终点的第K短路 二、思路 首先反向建图，从T点建立到各点的边，求出T终点到各点的最短距离最为估价函数,用f数组保存。 bfs将fd = 距离 + 估价值入队，每次从估价值最少的点出队，若这个点等于T点且已经被遍历过K次那么直接输出答案。 由于是求第K短路，所以当一个点被遍历了K次那么久不用再入队了，因为它只会对k+1条路有用。 由于起点和终点可能相同，...
八数码问题的A*算法
shiandojyawa的专栏
11-27 2356
问题描述：八数码问题即是找出一条状态路径，使初始状态（start）转换到目标状态（end），一般选取目标状态为：1 2 3 4 5 6 7 8 0（0代表空格）  0   1   2               1   2   3   3   4   5  ——>   4  5   6  6   7   8               7  8   0 下面通过几个问题来对求解策略进行讨
双向BFS解决立体八数码问题的POJ 3131分析
- poj_八数码：表示该问题属于POJ平台上的八数码问题。 - poj：这是POJ平台的简称，表明该文件与POJ评测系统相关。 通过以上的知识点分析，我们可以得知POJ 3131题目是要求参与者使用双向BFS算法来解决一个经典的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值