POJ 1077 Eight

最新推荐文章于 2022-01-17 22:17:08 发布
最新推荐文章于 2022-01-17 22:17:08 发布
阅读量804 收藏
点赞数
分类专栏： POJ - A* ####### 搜索 ######## 文章标签： A_star BFS 康拓展开 priority_queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013569656/article/details/23627963
版权
POJ 同时被 3 个专栏收录
154 篇文章 1 订阅
订阅专栏
####### 搜索 ########
21 篇文章 0 订阅
订阅专栏
- A*
1 篇文章 0 订阅
订阅专栏

题目大意：

        只有一个测例，求解八数码问题，输入的是初始的八数码摆放位置，以一行显示，顺序是从上到下（行）从左到右显示，数字是1 ~ 8，空格用x表示，目标状态为排列1 ~ 8 + x，输出为空移动的方向，l、r、u、d的序列（无空格）表示左右上下。

题目链接

A*：

注释代码：

/*  
 * Problem ID : POJ 1077 Eight
 * Author     : Lirx.t.Una  
 * Language   : G++  
 * Run Time   : 32 ms  
 * Run Memory : 3188 KB  
*/  

#pragma G++ optimize("O2")

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>

//表示数码个数
#define	N		8

//string length
//这里用字符串来存放数码状态
//加上x总共有9块砖
//最后一位留给'\0'
//因此长度为10
#define	STRLEN			10
//maximum factorial number
//最大阶乘号
//由于有九个数，因此对应着9!种状态
//将不同的数码状态利用康托展开映射到9!个数
//91 = 362880
#define	MAXFAC			362880
//maximum length of path
//即x移动的路径长度
//最大值经测试为25
#define	MAXPATHLEN		25
//总共有4中x的移动方法，即上下左右
#define	MOVN			4
//康托展开中所用到的阶乘个数
//由于数码中最大数字为9（将x转换为9）
//因此最大阶乘为(9-1)!
//阶乘从0!开始一直到8!
//因此为9中阶乘
#define FCN				9

using namespace std;

struct	Node {//每个结点存放一种数码状态

	//由于将每种状态都转化成一串1~9的字符了（x转换为9）
	//因此可以组成一个9位数，没有超出int范围
	//用int存比直接用字符串存节省空间（要考虑结构体数据对齐的情况）
	int		s;//即以int的形式数码字符串

	//以下为A*的估价函数的参数：
	//f = g + h
	//g为解空间树中到达当前位置的代价（即步数，根结点代价为0，因此即为边的数量）
    //h为当前状态到目标状态所要付出的代价，则个值一般以最小值计
	  //由于这里没有精确的最小值计算方法，因此只能用一些算法做近似
	  //这里h用h_val函数求得
	int		g;
	int		f;

	Node(void) {}

	Node( int ss, int gg, int hh ) :
		s(ss), g(gg), f( gg + hh ) {}//hh传参时就已经用h_val求出了

	bool
	operator<(const Node &oth)//使用有限队列，让f最小者一直处于堆顶
	const {
	
		return f > oth.f;
	}
};

struct	Fath {//Father Node
	//父结点
	//这里利用数组模拟解空间树
	//fath[i]就表示阶乘号为i的结点的父结点

	//里面存放了父结点的阶乘号fac
	//以及父结点到当前子结点的走法（lrud）movment
	int		fac;
	char	mov;
};

priority_queue<Node>	q;//queue，利用STL的priority_queue来模拟优先队列（小顶堆）

Fath	fath[MAXFAC];//解空间树
bool	vist[MAXFAC];//have visited?vist[i]表示阶乘号为i的结点是否被访问过

char	path[MAXPATHLEN];//从根结点触发到达目标结点过程中x所走过的路径
                         //即此问题的答案

//在移动x的时候将其动作转化到二维空间中的上下左右
//由于坐标系是朝右下角的，所以x正半轴朝下，y正半轴朝右
//(dx, dy)为x的移动向量
//分别对应着上下左右四种移动方式
int		dx[MOVN] = { 0, 0, -1, 1 };
int		dy[MOVN] = { -1, 1, 0, 0 };
char	mv[MOVN] = { 'l', 'r', 'u', 'd' };

//对应着0!~8!这9种阶乘
int		FC[FCN] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320 };

bool
cnsov(char *s) {//can solve this problem
	//测试所给的初始状态能否到达目标状态
	//目标状态就是排列123456789

	//方法是求初始状态的逆序数
	//注意！不包括空格x的序列的逆序数

	int		i, j;
	int		ord;//ordinal number，即逆序数的结果保存其中

	for ( ord = 0, i = 0; i < N; i++ )
		if ( '9' != s[i] )
			for ( j = i + 1; j <= N; j++ )
				if ( '9' != s[j] && s[i] > s[j] )
					ord++;

	if ( ord % 2 )//如果逆序数为奇数则不可解
		return false;
	
	return true;//否则可解
}

int
h_val(char *s) {//get h_value求估价函数的参数h

	int		i;
	int		h;

	//这里采用当前状态中每个格子的值和目标状态中每个对应格子中的绝对差值的方法
	//求和的方法估算h参数

	//对于当前状态中i号格子中放的数就是s[i]
	//而目标状态中i号格子中放的数是(i+'1')
	for ( h = 0, i = 0; i <= N; i++ )
		h += abs(s[i] - '1' - i);

	return h;
}

int
hash(char *s) {//康托展开，即一个哈希函数
	//将给定状态所表示的字符串映射到一个阶乘值上
	//可以使每个状态都有不同的阶乘号

	int		i, j;
	int		ord;//每个i号位置数所拥有的逆序数
	int		fac;//最终的字符串哈希值，即阶乘号

	for ( fac = 0, i = 0; i < N; i++ ) {

		for ( ord = 0, j = i + 1; j <= N; j++ )
			if ( s[i] > s[j] )
				ord++;

		//康托展开的核心求法
		//每一轮的逆序数乘以各自的阶乘数
		fac += FC[ s[i] - '1' ] * ord;
	}

	return fac;
}

void
fndx( char *s, int &x, int &y ) {//find x
	//找到状态中x的位置并求其二位坐标

	int		i;

	for ( i = 0; '9' != s[i]; i++ );

	x = i / 3;//横坐标
	y = i % 3;//纵坐标
}

void
swp( char *s, int i, int j ) {//swap
	//交换字符串中为位置i和位置j的字符

	char	tmp;

	tmp	 = s[i];
	s[i] = s[j];
	s[j] = tmp;
}

int
a_star(char *sini) {//A*算法
	//init string，根结点状态对应的字符串

	Node	nfath;//father node，父结点
	char	sfath[STRLEN];//father string，父结点状态对应的字符串
	char	schld[STRLEN];//children string，子结点对应的字符串
	int		fc;//children factorial number，子结点对应的阶乘号

	//(x, y)为父结点状态中x的坐标
	//(xx, yy)为子结点状态中x的坐标
	int		x, xx;
	int		y, yy;

	int		i;//计数变量

	q.push( Node( atoi(sini), 0, h_val(sini) ) );//先将根结点入队
	vist[ hash(sini) ] = true;//并将根结点置为访问过

	while ( true ) {
		//由于在main函数中已经先用cnsov函数判断过问题的可解性了
		//因此这里就默认问题是可解的
		//一定能return出a_star函数，因此这里就做了一个死循环
	
		//先弹堆获得一个父结点
		nfath = q.top();
		q.pop();

		//取出父结点的状态字符串并找到x的位置
		sprintf(sfath, "%d", nfath.s);
		fndx(sfath, x, y);

		for ( i = 0; i < MOVN; i++ ) {//依次按照四种方向生成
			//父结点的子结点

			//子结点中x的位置是由父结点中x上下左右移动得来的
			xx = x + dx[i];
			yy = y + dy[i];

			//1. 如果x走出了3×3框架范围则直接排除考察范围
			if ( xx < 0 || xx > 2 || yy < 0 || yy > 2 )
				continue;

			//构造子结点的状态字符串
			strcpy(schld, sfath);
			swp( schld, 3 * x + y, 3 * xx + yy );

			//2. 如果子结点已经被访问过了则也直接排除考察范围
			if ( vist[ fc = hash(schld) ] )//必须通过获得子结点的阶乘号
				//才可以获得它的vist的信息
				continue;

			//如果没有访问过则需要对其进行详细考察

			vist[fc] = true;//将其置为访问过

			fath[fc].fac = hash(sfath);//设置子结点的父结点的阶乘号
			fath[fc].mov = mv[i];//从父结点走到子结点的方法也需设置

			if ( !fc )//如果当前生成的子结点已经是目标结点了
				//目标结点123456789的阶乘值为0（因为无逆序数）
				return nfath.g + 1;//则直接返回从初始状态到目标状态的代价（即步数）

			//否则需要将子结点入队待下次有机会再考察
			q.push( Node( atoi(schld), nfath.g + 1, h_val(schld) ) );
		}
	}
}

int
main() {

	char	sini[STRLEN];//初始状态字符串
	char	c;//每次接受一个字符
	int		i;//计数变量

	for ( i = 0; i <= N; i++ ) {
	
		scanf("%s", &c);
		if ( 'x' == c )
			sini[i] = '9';
		else
			sini[i] = c;
	}
	sini[i] = '\0';

	if ( !cnsov(sini) ) {

		puts("unsolvable");
		return 0;
	}

	int		fc;//children factorial number，子结点阶乘号
	Fath *	pf;//pointer to father node，父结点指针

	i = a_star(sini);//i此时为path的长度
	//从0到i-1存放完整路径
	path[i--] = '\0';//左后以为放空字符

	fc = 0;//子结点指针初始化为0，即目标结点的阶乘号
	pf = fath;//父结点指针初始化为目标结点的父节点
	
	//从后往前构造path
	while ( i >= 0 ) {
	
		path[i--] = pf->mov;//父结点到子结点的走法

		fc = pf->fac;//将子结点上移为父结点
		pf = fath + fc;//将父结点上移为父父结点，即更新完的子结点的父结点
	}

	puts(path);//输出

	return 0;
}

无注释代码：

#pragma G++ optimize("O2")

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>

#define	N		8

#define	STRLEN			10
#define	MAXFAC			362880
#define	MAXPATHLEN		25
#define	MOVN			4
#define FCN				9

using namespace std;

struct	Node {

	int		s;
	int		g;
	int		f;

	Node(void) {}

	Node( int ss, int gg, int hh ) :
		s(ss), g(gg), f( gg + hh ) {}

	bool
	operator<(const Node &oth)
	const {
	
		return f > oth.f;
	}
};

struct	Fath {

	int		fac;
	char	mov;
};

priority_queue<Node>	q;

Fath	fath[MAXFAC];
bool	vist[MAXFAC];

char	path[MAXPATHLEN];

int		dx[MOVN] = { 0, 0, -1, 1 };
int		dy[MOVN] = { -1, 1, 0, 0 };
char	mv[MOVN] = { 'l', 'r', 'u', 'd' };

int		FC[FCN] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320 };

bool
cnsov(char *s) {

	int		i, j;
	int		ord;

	for ( ord = 0, i = 0; i < N; i++ )
		if ( '9' != s[i] )
			for ( j = i + 1; j <= N; j++ )
				if ( '9' != s[j] && s[i] > s[j] )
					ord++;

	if ( ord % 2 )
		return false;
	
	return true;
}

int
h_val(char *s) {

	int		i;
	int		h;

	for ( h = 0, i = 0; i <= N; i++ )
		h += abs(s[i] - '1' - i);

	return h;
}

int
hash(char *s) {

	int		i, j;
	int		ord;
	int		fac;

	for ( fac = 0, i = 0; i < N; i++ ) {

		for ( ord = 0, j = i + 1; j <= N; j++ )
			if ( s[i] > s[j] )
				ord++;

		fac += FC[ s[i] - '1' ] * ord;
	}

	return fac;
}

void
fndx( char *s, int &x, int &y ) {

	int		i;

	for ( i = 0; '9' != s[i]; i++ );

	x = i / 3;
	y = i % 3;
}

void
swp( char *s, int i, int j ) {

	char	tmp;

	tmp	 = s[i];
	s[i] = s[j];
	s[j] = tmp;
}

int
a_star(char *sini) {

	Node	nfath;
	char	sfath[STRLEN];
	char	schld[STRLEN];
	int		fc;

	int		x, xx;
	int		y, yy;

	int		i;

	q.push( Node( atoi(sini), 0, h_val(sini) ) );
	vist[ hash(sini) ] = true;

	while ( true ) {
	
		nfath = q.top();
		q.pop();

		sprintf(sfath, "%d", nfath.s);
		fndx(sfath, x, y);

		for ( i = 0; i < MOVN; i++ ) {

			xx = x + dx[i];
			yy = y + dy[i];

			if ( xx < 0 || xx > 2 || yy < 0 || yy > 2 )
				continue;

			strcpy(schld, sfath);
			swp( schld, 3 * x + y, 3 * xx + yy );

			if ( vist[ fc = hash(schld) ] )
				continue;

			vist[fc] = true;

			fath[fc].fac = hash(sfath);
			fath[fc].mov = mv[i];

			if ( !fc )
				return nfath.g + 1;

			q.push( Node( atoi(schld), nfath.g + 1, h_val(schld) ) );
		}
	}
}

int
main() {

	char	sini[STRLEN];
	char	c;
	int		i;

	for ( i = 0; i <= N; i++ ) {
	
		scanf("%s", &c);
		if ( 'x' == c )
			sini[i] = '9';
		else
			sini[i] = c;
	}
	sini[i] = '\0';

	if ( !cnsov(sini) ) {

		puts("unsolvable");
		return 0;
	}

	int		fc;
	Fath *	pf;

	i = a_star(sini);
	path[i--] = '\0';
	
	fc = 0;
	pf = fath;

	while ( i >= 0 ) {
	
		path[i--] = pf->mov;

		fc = pf->fac;
		pf = fath + fc;
	}

	puts(path);

	return 0;
}

IDA*：

注释代码：

无注释代码：

单词解释：

sliding：adj, 可滑动的，变化的

tile：n, 瓦片，瓷砖

pack：vt, 包装，塞满，捆扎

frame：n, 框架

object：n, 目标

scramble：vt, 使混杂，搅乱，攀登

slightly：adv, 稍微地，轻微地

letter：n, 字母

row：n, 行，排

Sam Loyd：人名，山姆·劳埃德，历史上第一个构造出不可解的15数码问题

frustrate：vt, 挫败，使感到灰心

compose of：由...组成

configuration：n, 配置，结构

__Lirx_t_Una__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
POJ1077 Eight A*
Kevin的博客
09-11 351
题目链接 http://poj.org/problem?id=1077 分析 直接用BFS进行状态扩展会超时，需要设计估价函数跑A*算法。 每次只能使一个数位置改变，因此未来的操作次数不会小于每个数当前位置于最终位置的曼哈顿距离之和。 用这个作为估价函数，用康托展开将排列映射成整数来记录某一状态是否访问过。 有一结论，如果列数为奇数，那么初始状态和最终状态的逆序对数奇偶性相同。 AC代码 // 调...
POJ 1077 算法
08-09
标题中的“POJ 1078 算法”指的是北京大学在线判题系统（Problem Online Judge，简称POJ）中的第1077题，这通常是一个编程竞赛或者算法练习题目。POJ是一个供程序员练习算法、提交代码并获取运行结果的平台，主要...
poj 1077 Eight（A*）
weixin_33863087的博客
08-31 76
经典的八数码问题，用来练习各种搜索=_=。这题我用的A*做的，A*的主要思想就是在广搜的时候加了一个估价函数，用来评估此状态距离最终状态的大概距离。这样就可以省下很多状态不用搜索。对于每个状态设置一个函数 h(x)，这就是估价函数了（可能名词不太对请见谅），再设置一个函数 g(x)， 这存的是初始状态到当前状态所用步数（或距离，视估价函数而定），再设函数 f(x) = g(x) + h(...
用 A* 解决八数码问题
hazqfp的专栏
02-27 948
#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
HDU-1043 逆向bfs 打表
刷题记录
03-11 211
Problem Description The 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 o...
poj 1077 Eight.md
11-17
poj 1077 Eight.md
poj.rar_poj
最新发布
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
poj 1077 Eight
birdforever的专栏
09-05 602
// poj 1077 Eight /* 普通的广搜题，因为忘了标记爆了好多次空间，吸取教训！ */ #include #include #include using namespace std; const int inf = 1=0 && v=0 && w
poj1077 Eight
A Cube Master
09-04 453
题意：经典的八数码问题，不废话了。         思路：BFS。
poj1077Eight
liwei_av的博客
08-20 281
题目：http://poj.org/problem?id=1077 原文链接:https://blog.csdn.net/dolfamingo/article/details/77825569 1.正向bfs; 2.反向bfs; 3.双向bfs; 1.正向bfs:用数组队列，用stl里面的队列会超时 #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;iostream...
POJ 1077 Eight（BFS）
jinghui_7的博客
12-17 362
Description The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, a
POJ - 1077 Eight（A∗算法）
00后的博客
01-17 432
POJ - 1077 Eight（A∗算法） #include<iostream> #include<algorithm> #include<map> #include<queue> #define x first #define y second using namespace std; typedef pair<int,string> PIS; typedef pair<char,string> PCS; int f(
POJ-1077 Eight （三种解法：IDA*、A*、bfs()+康托展开）
mjj1024的博客
04-23 838
题目链接：https://cn.vjudge.net/problem/POJ-1077（根据我自己的理解写的，有错误的地方希望大家可以指正一下，非常感谢！）IDA*解法：什么是IDA*算法？    IDA*是基于深搜的基础上的一种优化算法。    对于这个题来说，由于深搜算出最佳方案需要耗费很多的时间，所以我们就从假定最优解开始算起，若搜索不出来这个结果，就将假定最优解加一再搜一次，直到搜到与当前...
POJ 1077 Eight(八数码) 双向广搜
不若乘风来
12-28 979
DescriptionThe 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值