A*算法求解15数码问题

最新推荐文章于 2024-04-11 15:00:00 发布
最新推荐文章于 2024-04-11 15:00:00 发布
阅读量1w 收藏 53
点赞数 14
分类专栏： 算法 文章标签： A*算法 15数码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/greedystar/article/details/79971628
版权

目录

一、问题描述

二、算法简介

三、算法步骤

四、评估函数

五、参考资料

六、源代码（Java实现）

一、问题描述

利用A*算法进行表1到表2的转换，要求空白块移动次数最少。

转换规则为：空白块只可以与上下左右四个方向的相邻数字交换。

       表1 起始状态                     表2 目标状态

         

二、算法简介

A*算法是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。该算法综合了Best-First Search和Dijkstra算法的优点：在进行启发式搜索提高算法效率的同时，基于评估函数计算损失，保证找到一条最优路径。

算法能否找到最优解的关键在于评估函数的选择，A*算法的评估函数表示为：f(n) = g(n) + h(n)

f(n) 是从初始状态经由状态n到目标状态的代价估计

g(n) 是在状态空间中从初始状态到状态n的实际代价

h(n) 是从状态n到目标状态的最佳路径的估计代价

例如在8数码问题中，g(n) 表示状态空间树中搜索的层数，h(n) 表示状态n与目标状态中元素位置不同的元素个数。

三、算法步骤

设定两个集合，open集，close集

1.  将起始点加入open集（设置父亲节点为空）

2.  在open集中选着一个f(n)值最小的节点作为当前节点

    2.1 将当前节点从open集中移除，添加到close集

    2.2 如果当前节点为终点节点，那么结束搜索

    2.3 处理当前节点的所有邻接节点，规则如下：

       如果不在open集中，那么就将其添加到open集，并将该节点的父节点为当前节点

       如果已经添加到open集中，重新计算f(n)值，如果f(n)值小于先前的f(n)值，那么就更新open集中相应节点的f(n)

       如果该节点不可通过或者已经被添加到close集，那么不予处理

3、如果open集不为空，那么转到步骤2继续执行。

四、评估函数

1.   f(n) = 状态n状态空间树中的搜索深度 + 状态n与目标状态不同的元素个数

效果：与8数码问题使用了相同的评估函数，大概跑了30W步无法求出解

评价：效果极差，15数码问题的状态空间树要远复杂于8 数码问题，且15数码问题中空白块的移动更为复杂，此评估函数不适用。

2.   f(n) = 状态n状态空间树中的搜索深度 + 状态n与目标状态各个位置数字偏差的绝对值

效果：随着搜索的进行，空白块的移动集中在表格上部，表格下部几乎不移动 ，无法求出解

评价：因为下部数字较大，移动后差值较大造成评估值较大，因此搜索集中在了数值较小的部分，效果很差。

3.   f(n) = 状态n状态空间树中的搜索深度 + 状态n与目标状态各个元素的路径差值（一维数组各元素的距离差之和）

效果：空白块最终移动55步得到目标状态。

评价：效果比较理想，但h(n)还可继续优化。

4.   f(n) = 状态n状态空间树中的搜索深度 + 状态n与目标状态各个元素的曼哈顿距离

效果：空白块最终移动41步得到目标状态。

评价：效果理想。

实际上，1和2的评估函数效果大致相同，都将搜索局限在了一部分导致无法计算出问题的解。3实际是以一维数组各元素的距离差之和估计状态n到目标状态的曼哈顿距离，但此估计方式和计算平面两点的曼哈顿距离存在较大误差，因此只求解出可行解。

五、参考资料

A*算法详解，看完后全懂了

启发式搜索浅谈，解决八数码问题

六、源代码（Java实现）

Github地址：A*算法求解15数码问题

一颗贪婪的星
关注
  • 14
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
某航某个大作业：十五数码A*算法，Python实现
Ta_Ex_的博客
12-02 5483
引言 十五数码问题来源于美国的科学魔术大师萨姆·洛伊德，洛伊德的发明其实只是将重排九宫（即八数码问题）中的3 阶方阵扩大到4 阶方阵罢了。由于这个细微的变化，十五数码问题的规模远远大于八数码问题，八数码问题的规模较小，总的状态数为9！=362880个，而十五数码的状态数有16！约为20.9×〖10〗^12。状态数相差了8个数量级。 解的存在性（可达性） 如果一对数的前后位置与大小顺序相反，即前面...
C语言实现：使用A*算法来解决15数码问题
03-26
本报告利用A*算法，给出了15数码问题的C++算法实现。 A*算法是一种预测算法，主要用于寻路等，根据当前状态和目标状态之间的差异，预测到达目标需要多少开销，根据这个开销来判断下一次选择以那个状态开始。这个开销...
A*算法解决十五数码问题（Python程序、报告）
11-17
A*算法十五数码问题（Python解决，程序、报告），A*算法+不同启发函数+堆排序+哈希，大作业报告和程序，Python实现，Markdown文档编辑。
用A*算法解决十五数码问题（人工智能作业）
weixin_40433003的博客
12-27 5251
人工智能大作业：使用A*算法解决十五数码问题
python实现A*算法解决N数码问题
最新发布
cnn-jxx的博客
04-11 1039
基于A*算法来寻找一个网格（或图）上从初始状态到目标状态的最短路径。
java A*算法解决八数码、十五数码
01-11
一个java实现的A*算法来实现八数码，十五数码问题。启发函数为f(n)=d(n)+p(n)。本程序中八数码、十五数码均可计算，预先定义了初始状态和最终状态（可以根据需求改为控制台输入的）。
A*算法求解15数码问题（含详细注释解释，300行代码）
qq_44174803的博客
11-21 6316
问题描述： 算法程序: 设计一个启发函数,利用A算法求解15数码问题。 要求: 尽可能用与A算法一致的思路实现算法, 力求简单明了地给出一个解. 一、A*算法 A算法是一种常用的启发式搜索算法。 在A算法中，一个结点位置的好坏用估价函数来对它进行评估。 A*算法的估价函数可表示为： f’(n) = g’(n) + h’(n) 这里，f’(n) 是估价函数， g’(n) 是起点到终点的最短路径值，h’(n)是n到目标的最短路经的启发值。由于这个 f’(n) 无法预先知道，所以实际上使用的是下面的估价函数：
人工智能A*算法15数码python实现
03-12
基于python实现的A*算法15数码，18级学姐自主完成的作业，呕心沥血，如果在语言规范上存在不足，那就。就憋着！哈哈哈哈哈，代码仅供参考，自己亲自码代码更酸爽！
C++实现A*算法十五数码问题
05-04
在这个特定的项目中，我们讨论的是如何使用C++来实现A*算法来解决“十五数码”问题，这是一个经典的逻辑游戏，也被称为“15滑块谜题”。下面将详细阐述A*算法的原理及其在C++中的实现，以及十五数码问题的背景和解决...
Java-A*算法解决八数码问题算法源码
10-29
用A*算法（人工智能或者数据结构与算法课程可能会学）解决八数码问题： 初始状态 目标状态 2 8 3 1 2 3 1 6 4 8 4 7 5 7 6 5 java实现方法在源码中。
利用神经网络启发的 A算法解决 15 数码问题
02-06
摘要 为了解决十五数码问题, 常用的方法是 A 算法, A 算法的好坏完全决定于启发函数 h 的选择. 在 15 数码问题中, 常用的启发函数有错位数和曼哈顿距离, 但这样的启发函数距离真实的代价差距还是很大的. 同时我们可以注意到, 启发函数可以看作当前状态到预测代价的映射, 因此利用神经网络训练启发函数是完全合理的. 实验证明, 在搜索深度比较大的情况下, 神经启发函数比曼哈顿距离找到最优解的速度可能会快上甚至上千倍 代码说明 main.py 程序的入口 board.py 负责一些基本操作: 比如是否为解, 判断可行的移动方向, 移动棋子 utils.py 数据结构类: Node 用于存储最优路径, PriorityQueue 负责探索 f(state)最小的状态 intelligence.py 基本的 A*算法, 曼哈顿距离和判断是否有解的算法 neural_network.py 用于训练和产生神经启发函数 ans/neu_ans[num].txt或man_ans[num].txt 存储使用 neu 和 man 的解(主要是判断 neu 产生的解是最优的), 还记录了
fifteen_digital_十五数码难题_
09-29
使用A-star算法解决十五数码难题，python环境下大约2s即可解决，关键在于评价函数的加权处理。
十五数码游戏
11-14
十五数码游戏：由15个编有1至15并放在4*4方格棋盘上的课走动的棋子组成。棋盘上总有一格是空的，以便可能让空格周围的棋子走进空格，这也可以理解为移动空格。每一空格其上下左右的数码可移至空格。问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
15数码问题源代码（c++）
12-22
c++版本的求解15数码问题算法源代码2
A*算法求解八数码问题_C#语言
11-20
A*算法求解八数码问题 1、A*算法基本思想： 1）建立一个队列，计算初始结点的估价函数f，并将初始结点入队，设置队列头和尾指针。 2）取出队列头（队列头指针所指）的结点，如果该结点是目标结点，则输出路径，程序...
十五数码——原理及实现（C语言）
D77的博客
10-15 3083
目录 1、问题描述 2、原理及方法 2.1 启发式图搜索 2.1.1 启发式图搜索 2.1.2 启发式搜索算法A 2.2 A* 3、算法设计 3.1 数据结构 3.1.1 结构体 3.1.2 数组 3.1.3 链表 3.2 函数 3.2.1 寻找0点位置 3.2.2 比较函数 3.2.3 移动函数 3.2.4 复制函数 3.2.5 输出函数 3.2.6 计算评价函数 3.3 循环 3.4 最小状态min 4、实验结果 1、问题描述 设计一个启发函数，利用A*算.
用A*算法解决15数码问题（8数码问题）c++
qq_41506927的博客
01-13 3076
十五数码问题 十五数码问题是人工智能中状态搜索中的经典问题，其中，该问题描述为：在4×4的棋盘，摆有十五个棋子，每个棋子上标有1至15的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。 这是一个典型的图搜索问题，但是该问题并不需要正在建立图数据结构来进行
运用A*算法解决八数码问题
05-23
八数码问题是指在3x3的九宫格中，给定八个数字和一个空格，要求将数字移动，最终达到目标状态。其中，每个数字可以向上、下、左、右四个方向移动，但不能跨越其他数字，也不能移动到九宫格外。 A*算法是一种启发式搜索算法，它通过估计到达目标的成本来决定哪些节点应该先被扩展。在八数码问题中，我们可以用曼哈顿距离来作为启发函数，即当前状态与目标状态之间所有数字的曼哈顿距离之和。曼哈顿距离指的是两个点在网格中沿着网格线走的距离之和。 具体实现步骤如下： 1. 定义状态表示：使用一个3x3的矩阵来表示当前状态，其中0表示空格。 2. 定义状态扩展：对于一个状态，枚举空格可以移动的四个方向，将空格与相邻位置的数交换，生成新的状态。 3. 定义启发函数：计算当前状态与目标状态之间所有数字的曼哈顿距离之和。 4. 定义状态比较：比较两个状态是否相同。 5. 定义搜索过程：使用A*算法进行搜索，将状态按照启发函数的值从小到大排序，每次扩展启发函数值最小的状态，并将它的后继状态加入到搜索队列中。如果搜索到目标状态，搜索结束。 6. 输出解路径：在搜索过程中，记录每个状态的父状态，最终从目标状态开始回溯到初始状态，得到解路径。 具体实现过程可以参考以下Python代码： ```python import heapq class Puzzle: GOAL = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] def __init__(self, state): self.state = state self.f = self.g = self.h = 0 self.parent = None def __lt__(self, other): return self.f < other.f def __eq__(self, other): return self.state == other.state def __hash__(self): return hash(str(self.state)) def is_goal(self): return self.state == Puzzle.GOAL def get_neighbors(self): neighbors = [] row, col = self.find(0) for dr, dc in [(1, 0), (0, 1), (-1, 0), (0, -1)]: nr, nc = row + dr, col + dc if 0 <= nr < 3 and 0 <= nc < 3: neighbor = self.clone() neighbor.swap(row, col, nr, nc) neighbors.append(neighbor) return neighbors def find(self, value): for i in range(3): for j in range(3): if self.state[i][j] == value: return i, j return None def swap(self, r1, c1, r2, c2): self.state[r1][c1], self.state[r2][c2] = self.state[r2][c2], self.state[r1][c1] def clone(self): clone = Puzzle([row[:] for row in self.state]) clone.g = self.g + 1 clone.h = clone.manhattan_distance() clone.f = clone.g + clone.h clone.parent = self return clone def manhattan_distance(self): distance = 0 for i in range(3): for j in range(3): if self.state[i][j] != 0: r, c = self.find(self.state[i][j]) distance += abs(i - r) + abs(j - c) return distance def print_path(self): path = [] node = self while node is not None: path.append(node) node = node.parent path.reverse() for node in path: print(node) def solve(start): open_set = [start] closed_set = set() while open_set: current = heapq.heappop(open_set) if current.is_goal(): return current.print_path() closed_set.add(current) for neighbor in current.get_neighbors(): if neighbor in closed_set: continue if neighbor not in open_set: heapq.heappush(open_set, neighbor) else: existing = open_set[open_set.index(neighbor)] if neighbor.g < existing.g: existing.g = neighbor.g existing.parent = neighbor.parent existing.f = existing.g + existing.h if __name__ == '__main__': start = Puzzle([[1, 2, 0], [4, 5, 3], [7, 8, 6]]) start.h = start.manhattan_distance() start.f = start.g + start.h solve(start) ``` 在这个实现中，我们使用了一个优先队列来保存待扩展的状态，每次从中选择f值最小的状态进行扩展。对于已经搜索过的状态，我们使用一个集合来保存，避免重复搜索。在搜索结束后，我们通过回溯记录的父状态，输出解路径。 这个算法的时间复杂度为O(b^d)，其中b是每个状态的平均分支因子，d是目标状态的深度。在实践中，A*算法通常能够在合理的时间内找到解，但在某些情况下可能会陷入无限循环或者搜索空间过大导致运行时间超过预期。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值