八数码的A*与IDA*算法-搜索进阶练习1

最新推荐文章于 2024-05-16 22:44:31 发布
最新推荐文章于 2024-05-16 22:44:31 发布
阅读量527 收藏
点赞数 1
分类专栏： 搜索 文章标签： 搜索 A IDA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ling_xiao007/article/details/50958834
版权

八数码的A*与IDA*算法-搜索进阶练习1

题意：众所周知的八数码问题，就不再描述了。不得不说，为了练习A*以及IDA*就直接看题解了。 了解之后分析如下。

解题报告：

先谈A*。A*是一种 启发式搜索，也就是说在每次搜索前，先进行在状态空间中对每一个搜索的位置通过f(n) = g(n) + h(n)进行评估，得到最好的位置，再从这个位置，进行搜索直到目标。其中f(n)是从初始点经由节点n到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。

然后是IDA*。A*算法和迭代加深算法的结合。

1.搜索框架？ A*（IDA*）算法。搜索直到终态结束，或该状态非法进行下一状态。
2.状态？ 直接记录每个状态的maze、x位置信息以及A*所需f、g、h。同时使用hash值指向所有状态。
3.状态转移？ x与上下左右互换，更新状态信息。
4.剪枝？ 一个简单有效的剪枝逆序数为奇则必定无解。
5.hash以及h？ hash可通过各位置逆序数乘位置散列值之和散列。h为所有数字块的曼哈顿距离和。

具体而言。A*通过构造优先队列实现搜索。构造优先队列时当f相同时按照g值从大到小排序，这样又是一个很给力的减枝。 

#include <cstdio>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

//A*: 因为每次移动都会影响一个点的曼哈顿距离（不算x）
//构造h()为所有数字块的曼哈顿距离和，用逆序数hash（算x）
//根据逆序数奇偶性（不算x）减掉无法到达的情况，
struct Node
{
	char maze[3][3];
	int r, c, f, g, h;		//(x, y); f = g + h
							/*f(n) 是从初始点经由节点n到目标点的估价函数，
							g(n) 是在状态空间中从初始节点到n节点的实际代价，
							h(n) 是从n到目标节点最佳路径的估计代价。*/
	Node() {}
	Node(const Node & rhs)
	{
		for (int i = 0; i < 3; i++)
			for (int j = 0; j < 3; j++)
				maze[i][j] = rhs.maze[i][j];
		r = rhs.r, c = rhs.c, g = rhs.g, f = rhs.f, h = rhs.h;
	}
	//估价函数小的先出队，相同则实际代价大的先出队
	friend bool operator < (const Node & a, const Node & b)
	{
		if (a.f == b.f) return a.g < b.g;
		return a.f > b.f;
	}
}st;

const int dir[4][2] = { { 1,0 },{ 0,1 },{ -1,0 },{ 0,-1 } };//方向
char dr[5] = "drul";										//方向查找表
int pos[9][2] = {0,0,0,1,0,2,1,0,1,1,1,2,2,0,2,1,2,2};		//位置信息		
int fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320 };		//hash散列因子
char path[370000];
bool vis[370000];
int pre[370000];
int shash;

int h(const Node s)			//估价函数，偏移步数
{
	int ans = 0;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			if (s.maze[i][j] == 'x') continue;
			int c = s.maze[i][j] - '1';
			int x = pos[c][0], y = pos[c][1];
			ans += (abs(x - i) + abs(y - j));
		}
	return ans;
}

int hash_node(const Node s) //hash散列，储存状态
{
	int ans = 0;
	char str[10];
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			int cnt = 0;
			str[i * 3 + j] = s.maze[i][j];
			for (int k = 0; k < i * 3 + j; k++)
				if (str[k] > str[i * 3 + j]) cnt++;
			ans += fac[i * 3 + j] * cnt;
		}
	return ans;
}

bool check_h()				//逆序为奇返回true
{
	int cnt = 0;
	char str[10];
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			str[i * 3 + j] = st.maze[i][j];
			if (st.maze[i][j] == 'x') continue;
			for (int k = 0; k < i * 3 + j; k++)
			{
				if (str[k] == 'x') continue;
				if (str[k] > str[i * 3 + j]) cnt++;
			}
		}
	return cnt & 1;
}

bool bfs()
{
	priority_queue<Node> q;
	q.push(st);
	memset(vis, false, sizeof(vis));
	vis[shash] = true;
	while (!q.empty())
	{
		Node u = q.top(); q.pop();
		int ihu = hash_node(u);
		for (int d = 0; d < 4; d++)
		{
			Node v(u);
			v.r = u.r + dir[d][0], v.c = u.c + dir[d][1];
			if (v.r < 0 || v.r >= 3 || v.c < 0 || v.c >= 3) continue;
			//更新地图
			v.maze[u.r][u.c] = v.maze[v.r][v.c];
			v.maze[v.r][v.c] = 'x';					
			v.g++, v.h = h(v); v.f = v.g + v.h;	//更新f = g + h
			int ihv = hash_node(v);
			if (vis[ihv]) continue;
			vis[ihv] = true; pre[ihv] = ihu;
			path[ihv] = dr[d];
			if (ihv == 0) return true;			//搜索结束
			q.push(v);
		}
	}
	return false;
}

void print(int h)
{
	if (h != shash)
	{
		print(pre[h]);
		putchar(path[h]);
	}
}

char in[100];

int main()
{
	while (gets_s(in))
	{
		for (int i = 0, x = 0, y = 0; in[i]; i++)
			if ((in[i] <= '8' && in[i] >= '1') || in[i] == 'x')
			{
				st.maze[x][y] = in[i];
				if (in[i] == 'x') st.r = x, st.c = y;
				y++;
				if (y == 3) x++, y = 0;
			}
		if (check_h()) { puts("unsolvable"); continue; }
		st.g = 0; st.h = h(st); st.f = st.h;
		if ((shash = hash_node(st)) == 0) { puts(""); continue; }
		int thash = bfs();
		print(0);			//递归输出答案
		puts("");
	}
	return 0;
}


而IDA*的话，和A*相同的h()函数。当前h深度下一层一层地进行搜索。 

#include <cstdio>
#include <algorithm>
using namespace std;

struct Node
{
	int r, c, f, g, h;
	char maze[3][3];
	Node(){}
	Node(const Node & rhs) {
		for (int i = 0; i < 3; i++)
			for (int j = 0; j < 3; j++)
				maze[i][j] = rhs.maze[i][j];
		r = rhs.r, c = rhs.c;
	}
}ts, s;

const int maxn = 370000;
const int dir[4][2] = { { 1,0 },{ 0,1 },{ -1,0 },{ 0,-1 } };
const char dr[5] = "drul";
const int fac[9] = { 1,1,2,6,24,120,720,5040,40320 };
const int pos[][2] = { 0,0,0,1,0,2,1,0,1,1,1,2,2,0,2,1,2,2 };
char path[maxn];
bool vis[maxn];
int deep;

int h(const Node st) {
	int ans = 0;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			if (st.maze[i][j] == 'x') continue;
			int c = st.maze[i][j] - '1';
			ans += abs(pos[c][0] - i) + abs(pos[c][1] - j);
		}
	return ans;
}

int mhash(const Node st) {
	char str[10];
	int ans = 0;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			str[i * 3 + j] = st.maze[i][j];
			int cnt = 0;
			for (int k = 0; k < 3 * i + j; k++)
				if (str[k] > str[i * 3 + j]) cnt++;
			ans += cnt * fac[i * 3 + j];
		}
	return ans;
}

bool check() {				//剪枝, 逆序数为奇返回1
	char str[10];
	int cnt = 0;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			str[i * 3 + j] = s.maze[i][j];
			if (s.maze[i][j] == 'x') continue;
			for (int k = 0; k < 3 * i + j; k++)
			{
				if (str[k] == 'x') continue;
				if (str[k] > str[i * 3 + j]) cnt++;
			}
		}
	return cnt & 1;
}

int dfs(int d) {
	//搜索完成
	if (h(ts) == 0) return true;
	//超过当前的搜索深度   
	if (h(ts) + d > deep) return false;
	//当前r、c
	int r = ts.r, c = ts.c;
	for (int dd = 0; dd < 4; dd++)
	{
		int nr = ts.r + dir[dd][0], nc = ts.c + dir[dd][1];
		if (nr < 0 || nc < 0 || nr > 2 || nc > 2) continue;
		ts.maze[r][c] = ts.maze[nr][nc];
		ts.maze[nr][nc] = 'x';
		int ihv = mhash(ts);
		if (vis[ihv]) {
			ts.maze[nr][nc] = ts.maze[r][c];
			ts.maze[r][c] = 'x';
			continue;
		}
		vis[ihv] = true;
		ts.r = nr, ts.c = nc;
		path[d] = dr[dd];
		if (dfs(d + 1)) return true;
		vis[ihv] = false;
		ts.r = r, ts.c = c;
		ts.maze[nr][nc] = ts.maze[r][c];
		ts.maze[r][c] = 'x';
	}
	return false;
}

int main() {
	char in[100];
	while (gets_s(in))
	{
		for (int i = 0, x = 0, y = 0; in[i]; i++)
			if (in[i] == 'x' || (in[i] > '0' && in[i] < '9'))
			{
				if (in[i] == 'x') s.c = y, s.r = x;
				s.maze[x][y++] = in[i];
				if (y == 3) y = 0, x++;
			}
		if (check()) { puts("unsolvable"); continue; }
		memset(vis, false, sizeof(vis));
		vis[mhash(s)] = true;
		ts = s; deep = 0;
		while (true)
		{
			if (dfs(0)) break;
			deep++;
		}
		for (int i = 0; i < deep; i++)
			putchar(path[i]);
		puts("");	
	}
	return 0;
}

最后打卡一下。之前Ubuntu的ibus默认的中文输入法双拼的，当时就感觉是一堆乱码，玩毛。不几天前，尝试用双拼了。


ling_xiao007
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
与A*算法相比，IDA*可以在更严格的内存限制下找到路径，而`output_ida_1.txt`和`output_ida_2.txt`则是使用IDA*算法解决迷宫问题的输出结果。 综合以上，我们可以看到这些文件共同展示了如何在实际问题中运用高级...
八数码 poj1077 Eight（A*、IDA*)
冰
03-13 2440
八数码主要参考：刘亚宁学长的八数码八境界 等 A*主要参考：百度百科，初识A*算法，深入A*算法 等 IDA*主要参考：http://blog.csdn.net/urecvbnkuhbh_54245df/article/details/5856756，http://blog.csdn.net/nomad2/article/details/6562140 等 人工智能课的作业，借此研究下八数码
POJ-1077 Eight （三种解法：IDA*、A*、bfs()+康托展开）
mjj1024的博客
04-23 838
题目链接：https://cn.vjudge.net/problem/POJ-1077（根据我自己的理解写的，有错误的地方希望大家可以指正一下，非常感谢！）IDA*解法：什么是IDA*算法？    IDA*是基于深搜的基础上的一种优化算法。    对于这个题来说，由于深搜算出最佳方案需要耗费很多的时间，所以我们就从假定最优解开始算起，若搜索不出来这个结果，就将假定最优解加一再搜一次，直到搜到与当前...
基于迭代加深的A*算法求解八数码问题
最新发布
Golemon的博客
05-16 1056
八数码问题是一个经典的拼图游戏，通过移动数字方块来重新排列它们，使得它们按照从小到大的顺序排列，并且留出一个空格作为移动的空间。123456780A*算法是一种用于路径搜索的启发式算法。它评估每个可能路径的代价，找到起点到终点的最佳路径。算法包括定义启发式评估函数、维护开放和关闭列表、评估节点、选择最佳节点、更新路径和重复步骤直到找到最佳路径或无法到达终点。迭代加深搜索则是一种深度优先搜索算法的改进版，通过逐步增加搜索深度的方式提高搜索效率。
八数码问题——A*算法的应用（A-Star）
Beihai_Van的博客
04-03 2488
A* 算法的核心思想是综合考虑两个方面的信息：从起始节点到当前节点的实际代价（通常是已经走过的路径的代价），以及从当前节点到目标节点的估计代价（启发式函数）。这两方面的信息通过综合起来选择估计代价最小的节点进行搜索，朝着目标节点前进。
A*算法解决八数码问题，对比九数码问题
dick的博客
01-17 4580
A*算法求解八数码问题 Github仓库：https://github.com/dick20/Artificial-Intelligence 问题介绍   八数码问题也称为九宫问题。在3x3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始状态转变成目标...
【POJ1077】Eight 八数码问题，解题报告+思路+代码
c0de4fun的完美算(nei)法(he)教室-我们仍不知道，那天调用的驱动的名字。
03-24 5584
#include #include #include #define INPUT using namespace std; /** Problem : poj1077,hdu1043，经典的八数码问题。 知识点： BFS + HASH + 打表 + 父亲节点记录 境界：3 - BFS+HASH+打表 A了两天！！！ 记得拿启发式，双向BFS重新写
人工智能-IDA*算法解决15-puzzle问题（能优化的都优化了）
04-08
IDA*算法是A*算法的一种变体，它通过反复进行深度优先搜索（DFS），每次增加搜索深度的上限，直到找到解决方案。A*算法是启发式搜索算法，结合了广度优先搜索（BFS）的最优路径保证和启发式函数（通常表示为f(n) = g...
15 puzzle C语言IDA* 求解算法
10-23
《15 Puzzle与IDA*算法在C语言中的实现》 15 Puzzle，又称15数字谜题，是一种经典的智力游戏，玩家需要通过滑动15个数字方块，使得它们最终按照1到15的顺序排列，空白方块通常位于右下角。这个游戏的挑战在于寻找...
A*,IDA*等搜索算法说明+源代码
04-14
本文将深入探讨两种经典的启发式搜索算法——A*（读作“A星”）和IDA*（Iterative Deepening A*），并简要提及Dancing Links算法，这些算法都是计算机科学竞赛（如ACM/ICPC）中常见的知识点。 **A*搜索算法** A*...
八数码IDA*实现
12-27
代码注释清晰，逻辑连贯，有助于理解IDA*和八数码问题
PKU-1077 Eight (八数码之IDA*)
gk1988的专栏
05-18 609
原题链接：http://poj.org/problem?id=1077 Eight 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
八数码问题 IDA*算法+曼哈顿距离 poj 1077
行风
06-22 5867
http://hi.baidu.com/wangz_j/blog/item/8dad3fcfbf31e41593457e51.htmlIDA*即迭代加深的A*搜索，实现代码是最简练的，无须状态判重，无需估价排序。那么就用不到哈希表，堆上也不必应用，空间需求变的超级少。效率上，应用了曼哈顿距离。同时可以根据深度和h值，在找最优解的时候，对超过目前最优解的地方进行剪枝，这可以导致搜索深度的急剧
八数码难题 (IDA*解法）
lcey_的博客
05-18 903
翻题解的时候看到大佬们都打的双向广搜。（蒟蒻在墙角瑟瑟发抖 在这里提供一种IDA*解法， 还是一层层地搜索，如果超出预期层数就返回 然后用评估函数进行剪枝（就是可行性剪枝） 感觉写起来比双向广搜好多了 评估函数越好，搜索效率越高； 如果评估函数太差，那IDA*和普通爆搜复杂度差不多。 所有一个好的评估函数很关键； 主要是看这道题评估函数(h)怎么写， 对于评估函数想到的有两个方案： 方案一：不在自...
HDU1043——八数码IDA*算法
uyret的博客
04-13 634
之前写八数码用了广搜，从目标状态扩展路径，把所有可以走到的状态都标记起来，然后输入后直接判断这个状态是否被标记过，但是在poj上正确，在HDU上一直超时，poj时间是5000ms，HDU是1000ms,妥妥的超了，wrong使我进步，又恶补了IDA*的知识。先介绍一下我理解的IDA*，首先判断当前数码位置状态与目标数码位置状态是否可互达（后附简单介绍），如果不可以直接剪枝，如果可以，就算出当前状态...
POJ 1077 Eight（八数码A*+IDA*）
piaocoder
04-05 910
Eight 题目链接： http://poj.org/problem?id=1077 解题思路： 题目大意： 将分别标有数字1，2，3，…，8的八块正方形数码牌任意地放在一块3×3的数码盘上。放牌时要求不能重叠。于是，在3×3的数码盘 上出现了一个空格。现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘摆成如下的状态。 1 2 3 4 5 6 7
人工智能-A*算法-八数码-java
qq_67366800的博客
12-13 276
对于棋盘的移动，首先判断棋盘中数字0所在的位置，如果0的下标是0,3,6就不能往左移动，如果下标是0,1,2就不能往上移动，如果下标是2,5,8就不能往右移动，如果下标是6,7,8就不能往下移动，此外，如果棋盘是由父棋盘状态向下运行得到，则当前棋盘就不能往上移动，其他方向同理，移动时交换数字位置即可。针对给定的一种初始布局和目标状态，如何移动将牌，实现从初始状态到目标状态的转变。同A*算法（估价函数为不在位个数）思路一致，区别在于第二步计算的是初始状态和目标状态的曼哈顿距离和当前所在层数。
学习记录 -- A*，IDA*算法
weixin_73285275的博客
08-09 141
2.空间需求减少：每个深度下实际上是一个深度优先搜索，不过深度有限制，使用 DFS 可以减小空间消耗。当然，我也用了IDA*，方法当然还是掌握的越多越好，不过这个提交跑的好像还没有我写的A*快。跟八数码差不多，只是这题规定了在15步之内（像极了迭代加深IDA*，但是现在我用A*）。题目求给定的数组变成目标数组需要的最少操作数（操作：只能交换'0'和与它相邻的位置）。3.重复搜索：即使前后两次搜索相差微小，回溯过程中每次深度变大都要再次从头搜索。：bfs + 启发式搜索（比普通搜索多一个估价函数）。
A*与IDA*搜索算法解析
首先，文章回顾了基础的搜索算法，如宽度优先搜索（BFS）和Dijkstra算法，然后详细讨论了A*启发式搜索以及IDA*的迭代加深深度优先搜索。 1. **宽度优先搜索（BFS）** BFS适用于解决无权图中最短路径问题，因为它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值