八数码问题求解--实验报告

合集下载

A星算法求解八数码技术报告

A星算法求解八数码技术报告

A*算法求解八数码问题●open 表、closed 表数据结构的选择:1)把s放入open表,记f=h,令closed为空表。

2)重复下列过程,直到找到目标节点为止。

若open表为空表,则宣告失败。

3)选取open表中未设置过的具有最小f值的节点为最佳节点bestnode,并把它放入closed表。

4)若bestnode为一目标节点,则成功求得一解。

5)若bestnode不是目标节点,则扩展之,产生后继节点succssor。

6)对每个succssor进行下列过称:a)对每个succssor返回bestnode的指针。

b)计算g(suc)=g(bes)+k(bes,suc)。

c)如果succssore open,称此节点为old,并填到bestnode的后继节点表中。

d)比较新旧路劲代价。

如果g(suc)<g(old),则重新确定old的父辈节点为bestnode,记下较小代价g(old),并修真f(old)值。

e)若至old节点的代价较低或一样,则停止扩展节点。

f)若succssore不再closed表中,则看其是否在closed表中。

g)若succssore在closed表中,则转向(c)。

h)若succssore既不在open表中,又不在closed表中,则把它放入open表中,并添入bestnode后裔表中,然后转向(7)。

i)计算f值j)Go loop●节点的数据结构:static int target[9]={1,2,3,8,0,4,7,6,5}; 全局静态变量,表示目标状态class eight_num{private:int num[9]; 定义八数码的初始状态int not_in_position_num; 定义不在正确位置八数码的个数int deapth; 定义了搜索的深度int eva_function; 评价函数的值,每次选取最小的进行扩展public:eight_num* parent; 指向节点的父节点eight_num* leaf_next; 指向open表的下一个节点eight_num* leaf_pre; 指向open 表的前一个节点初始状态的构造函数eight_num(int init_num[9]);eight_num(int num1,int num2,int num3,int num4,int num5,int num6,int num7,int num8,int num9){}eight_num(void){ }计算启发函数g(n)的值void eight_num::cul_para(void){}显示当前节点的状态void eight_num::show(){}复制当前节点状态到一个另数组中void eight_num::get_numbers_to(int other_num[9]){}设置当前节点状态(欲设置的状态记录的other数组中)void eight_num::set_num(int other_num[9]){}eight_num& eight_num::operator=(eight_num& another_8num){} eight_num& eight_num::operator=(int other_num[9]){}int eight_num::operator==(eight_num& another_8num){}int eight_num::operator==(int other_num[9]){}空格向上移int move_up(int num[9]){}空格向下移int move_down(int num[9]){}空格向左移int move_left(int num[9]){}空格向右移int move_right(int num[9]){}判断可否解出int icansolve(int num[9],int target[9]){}判断有无重复int existed(int num[9],eight_num *where){}寻找估价函数最小的叶子节点eight_num* find_OK_leaf(eight_num* start){}}A*算法求解框图:●分析估价函数对搜索算法的影响:估价函数就是评价函数,它用来评价子结点的好坏,因为准确评价是不可能的,所以称为估值。

A星算法求八数码问题实验报告

A星算法求八数码问题实验报告

A星算法求八数码问题实验报告人工智能实验报告实验名称:八数码问题姓名:xx学号:2012210xxxx计算机学院2014年1月14日一.实验目的掌握A*的思想,启发式搜索,来求解在代价最小的情况下将九宫格从一个状态转为另状态的路径。

二.实验内容给定九宫格的初始状态,要求在有限步的操作内,使其转化为目标状态,且所得到的解是代价最小解(2 8 31 6 47 0 52 8 31 6 47 0 5三、A*算法思想:1、思想:A*算法是一种静态路网中求解最短路最有效的直接搜索方法。

估价值与实际值越接近,估价函数取得就越好2、原理:估价函数公式表示为: f(n)=g(n)+h(n),其中 f(n) 是从初始点经由节点n到目标点的估价函数,g(n) 是在状态空间中从初始节点到n节点的实际代价,h(n) 是从n到目标节点最佳路径的估计代价。

保证找到最短路径(最优解的)条件,关键在于估价函数h(n)的选取:估价值h(n)<= n到目标节点的距离实际值,这种情况下,搜索的点数多,搜索范围大,效率低。

但能得到最优解。

并且如果h(n)=d(n),即距离估计h(n)等于最短距离,那么搜索将严格沿着最短路径进行此时的搜索效率是最高的。

如果估价值>实际值,搜索的点数少,搜索范围小,效率高,但不能保证得到最优解。

四、算法流程:Heuristic_Search(启发式搜索)While是从未拓展表中删N为目是,输出路径否,生成n的所有子状态Case:此子状Case:此子状Case:此子状计算该子状记录比已有记录比已有返回五、关键技术:1、使用了CreateChild()函数,求得了任意未拓展九宫格的扩展结点,便于拓展子空间,搜索所有情况。

关键代码:bool CreateChild(NOExtend ns[],NOExtend ne){int i,j,k=0;for(i=0;i<3;i++){for(j=0;j<3;j++){if(ne.cur_sudoku.num[i][j]==0){ //寻找九宫格空缺所在的坐标if(i-1>=0){ //将空格向上移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);//先把未改变的九宫格复制给九宫格数组的某一元素ns[k].cur_sudoku.num[i][j]=ne.cur_sudoku.num[i-1][j];//然后仅改变此二维九宫格的两项值即可ns[k].cur_sudoku.num[i-1][j]=0;ns[k].dx=1;k++;}if(j+1<=2){ //将空格向右移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i][j+1];ns[k].cur_sudoku.num[i][j+1]=0;ns[k].dx=1;k++;}if(i+1<=2){ //将空格向下移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i+1][j];ns[k].cur_sudoku.num[i+1][j]=0;ns[k].dx=1;k++;}if(j-1>=0){ //将空格向左移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i][j-1];ns[k].cur_sudoku.num[i][j-1]=0;ns[k].dx=1;k++;}return 1;}}}return 0;2、用启发式搜索函数寻找求解路径,运用了A*算法的思想,能够更快的求解出最优解。

【精编范文】八数码实验报告-推荐word版 (17页)

【精编范文】八数码实验报告-推荐word版 (17页)

本文部分内容来自网络整理,本司不为其真实性负责,如有异议或侵权请及时联系,本司将立即删除!== 本文为word格式,下载后可方便编辑和修改! ==八数码实验报告篇一:八数码实验报告利用人工智能技术解决八数码游戏问题1.八数码游戏问题简介九宫排字问题(又称八数码问题)是人工智能当中有名的难题之一。

问题是在3×3方格盘上,放有八个数码,剩下第九个为空,每一空格其上下左右的数码可移至空格。

问题给定初始位置和目标位置,要求通过一系列的数码移动,将初始位置转化为目标位置。

2.八数码游戏问题的状态空间法表示①建立一个只含有初始节点S0的搜索图G,把S0放入OPEN表中②建立CLOSED表,且置为空表③判断OPEN表是否为空表,若为空,则问题无解,退出④选择OPEN表中的第一个节点,把它从OPEN表移出,并放入CLOSED表中,将此节点记为节点n⑤考察节点n是否为目标节点,若是,则问题有解,成功退出。

问题的解就是沿着n到S0的路径得到。

若不是转⑥⑥扩展节点n生成一组不是n的祖先的后继节点,并将它们记为集合M,将M 中的这些节点作为n的后继节点加入图G中⑦对未在G中出现过的(OPEN和CLOSED表中未出现过的)集合M中的节点, 设置一个指向父节点n的指针,并把这些节点放入OPEN表中;对于已在G中出现过的M中的节点,确定是否需要修改指向父节点的指针;对于已在G中出现过并已在closed表中的M中的节点,确定是否需要修改通向他们后继节点的指针。

⑧ 按某一任意方式或某种策略重排OPEN表中节点的顺序⑨ 转③3.八数码游戏问题的盲目搜索技术宽度优先搜索:1、定义如果搜索是以接近起始节点的程度依次扩展节点的,那么这种搜索就叫做宽度优先搜索(breadth-first search)。

2、特点这种搜索是逐层进行的;在对下一层的任一节点进行搜索之前,必须搜索完本层的所有节点。

3、宽度优先搜索算法(1) 把起始节点放到OPEN表中(如果该起始节点为一目标节点,则求得一个解答)。

八数码问题求解实验报告

八数码问题求解实验报告

八数码问题求解(一)实验软件TC2.0或VC6.0编程语言或其它编程语言(二)实验目的1.熟悉人工智能系统中的问题求解过程;2.熟悉状态空间的盲目搜索和启发式搜索算法的应用;3.熟悉对八数码问题的建模,求解及编程语言的应用。

(三)实验内容八数码问题:在3×3的方格棋盘上,摆放着1到8这八个数码,有一个方格是空的,要求对空格执行空格左移,空格右移,空格上移,空格下移这四个操作使得棋盘从初始状态到目标状态。

输入初始状态和目标状态,输出从初始状态到目标状态的路径。

(四)实验代码#include"stdafx.h"#include<iostream>#include<ctime>#include<vector>using namespace std;const int ROW = 3;const int COL = 3;const int MAXDISTANCE = 10000;const int MAXNUM = 10000;typedef struct_Node{int digit[ROW][COL];int dist; // distance between one state and the destination int dep; // the depth of node// So the comment function = dist + dep.int index; // point to the location of parent} Node;Node src, dest;vector<Node> node_v; // store the nodesbool isEmptyOfOPEN() {for (int i = 0; i < node_v.size(); i++) {if (node_v[i].dist != MAXNUM)return false;}return true;}bool isEqual(int index, int digit[][COL]) {for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++) {if (node_v[index].digit[i][j] != digit[i][j])return false;}return true;}ostream& operator<<(ostream& os, Node& node) {for (int i = 0; i < ROW; i++) {for (int j = 0; j < COL; j++)os << node.digit[i][j] << ' ';os << endl;}return os;}void PrintSteps(int index, vector<Node>& rstep_v) { rstep_v.push_back(node_v[index]);index = node_v[index].index;while (index != 0) {rstep_v.push_back(node_v[index]);index = node_v[index].index;}for (int i = rstep_v.size() - 1; i >= 0; i--)cout << "Step " << rstep_v.size() - i<< endl << rstep_v[i] << endl;}void Swap(int& a, int& b) {int t;t = a;a = b;b = t;}void Assign(Node& node, int index) {for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++)node.digit[i][j] = node_v[index].digit[i][j];}int GetMinNode() {int dist = MAXNUM;int loc; // the location of minimize nodefor (int i = 0; i < node_v.size(); i++) {if (node_v[i].dist == MAXNUM)continue;else if ((node_v[i].dist + node_v[i].dep) < dist) {loc = i;dist = node_v[i].dist + node_v[i].dep;}}return loc;}bool isExpandable(Node& node) {for (int i = 0; i < node_v.size(); i++) {if (isEqual(i, node.digit))return false;}return true;}//扩展int Distance(Node& node, int digit[][COL]) {int distance = 0;bool flag = false;for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++)for (int k = 0; k < ROW; k++) {for (int l = 0; l < COL; l++) {if (node.digit[i][j] == digit[k][l]) {distance += abs(i - k) + abs(j - l);//abs()求得是正数的绝对值。

八数码问题 实验报告

八数码问题 实验报告

八数码问题实验报告八数码问题实验报告引言:八数码问题是一种经典的数学难题,在计算机科学领域有着广泛的研究和应用。

本实验旨在通过探索八数码问题的解法,深入理解该问题的本质,并通过实验结果评估不同算法的效率和准确性。

一、问题描述:八数码问题是一个在3×3的棋盘上,由1至8的数字和一个空格组成的拼图问题。

目标是通过移动棋盘上的数字,使得棋盘上的数字排列按照从小到大的顺序排列,最终形成如下的目标状态:1 2 34 5 67 8二、解法探索:1. 深度优先搜索算法:深度优先搜索算法是一种经典的解决拼图问题的方法。

该算法通过不断尝试所有可能的移动方式,直到找到目标状态或者无法再继续移动为止。

实验结果显示,该算法在八数码问题中能够找到解,但由于搜索空间庞大,算法的时间复杂度较高。

2. 广度优先搜索算法:广度优先搜索算法是另一种常用的解决八数码问题的方法。

该算法通过逐层扩展搜索树,从初始状态开始,逐步扩展所有可能的状态,直到找到目标状态。

实验结果显示,该算法能够找到最短路径的解,但同样面临搜索空间庞大的问题。

3. A*算法:A*算法是一种启发式搜索算法,结合了深度优先搜索和广度优先搜索的优点。

该算法通过使用一个估价函数来评估每个搜索状态的优劣,并选择最有希望的状态进行扩展。

实验结果显示,A*算法在八数码问题中表现出色,能够高效地找到最优解。

三、实验结果与分析:通过对深度优先搜索、广度优先搜索和A*算法的实验,得出以下结论:1. 深度优先搜索算法虽然能够找到解,但由于搜索空间庞大,时间复杂度较高,不适用于大规模的八数码问题。

2. 广度优先搜索算法能够找到最短路径的解,但同样面临搜索空间庞大的问题,对于大规模问题效率较低。

3. A*算法在八数码问题中表现出色,通过合理的估价函数能够高效地找到最优解,对于大规模问题具有较好的效果。

四、结论与展望:本实验通过对八数码问题的解法探索,深入理解了该问题的本质,并评估了不同算法的效率和准确性。

八数码 实验报告

八数码 实验报告

八数码实验报告八数码实验报告引言:八数码,也称为滑块拼图,是一种经典的数字游戏。

在这个游戏中,玩家需要通过移动数字方块,将它们按照从小到大的顺序排列。

本次实验旨在通过编写八数码游戏的程序,探索并实践算法设计与实现的过程。

实验过程:1. 游戏规则设计在开始编写程序之前,首先需要明确游戏的规则。

八数码游戏的规则如下:- 有一个3x3的方格,其中有8个方块分别带有数字1到8,还有一个空白方块。

- 玩家可以通过移动数字方块,将它们按照从小到大的顺序排列。

- 移动的方式是将数字方块与空白方块进行交换,只能上下左右移动。

2. 程序设计基于以上规则,我们开始设计程序。

首先,我们需要实现游戏界面的显示与交互。

通过使用图形界面库,我们可以方便地创建一个可视化的游戏界面。

在界面中,每个数字方块都是一个可交互的按钮,玩家可以通过点击按钮来移动数字方块。

接下来,我们需要实现游戏逻辑的处理。

当玩家点击一个数字方块时,程序需要判断该方块是否与空白方块相邻,如果相邻,则进行交换。

同时,程序还需要判断玩家是否已经成功完成了游戏,即数字方块是否已经按照从小到大的顺序排列。

为了实现这些功能,我们可以使用算法来进行判断和计算。

例如,可以通过遍历每个方块,检查其周围是否有空白方块,从而确定是否可以进行移动。

另外,可以使用排序算法来判断数字方块是否已经按照顺序排列。

3. 算法实现在实现算法时,我们可以选择不同的方法。

例如,可以使用深度优先搜索算法来寻找解决方案。

深度优先搜索算法通过递归地尝试每一种移动方式,直到找到一个可行的解决方案。

另外,还可以使用启发式搜索算法,如A*算法,来提高搜索效率。

在本次实验中,我们选择使用A*算法来解决八数码问题。

A*算法通过估计每个状态与目标状态的距离,选择最有可能导致解决方案的移动方式。

通过使用合适的启发函数,A*算法可以在较短的时间内找到一个最优解。

4. 实验结果经过程序的编写和测试,我们成功地实现了八数码游戏。

八数码实验报告

八数码实验报告

八数码实验报告八数码实验报告引言:八数码,也被称为滑块拼图,是一种经典的益智游戏。

在这个实验中,我们将探索八数码问题的解决方案,并分析其算法的效率和复杂性。

通过这个实验,我们可以深入了解搜索算法在解决问题中的应用,并且探讨不同算法之间的优劣势。

1. 问题描述:八数码问题是一个在3x3的方格上进行的拼图游戏。

方格中有8个方块,分别标有1到8的数字,还有一个空方块。

游戏的目标是通过移动方块,将它们按照从左上角到右下角的顺序排列。

2. 算法一:深度优先搜索(DFS)深度优先搜索是一种经典的搜索算法,它从初始状态开始,不断地向前搜索,直到找到目标状态或者无法继续搜索为止。

在八数码问题中,深度优先搜索会尝试所有可能的移动方式,直到找到解决方案。

然而,深度优先搜索在解决八数码问题时存在一些问题。

由于搜索的深度可能非常大,算法可能会陷入无限循环,或者需要很长时间才能找到解决方案。

因此,在实际应用中,深度优先搜索并不是最优的选择。

3. 算法二:广度优先搜索(BFS)广度优先搜索是另一种常用的搜索算法,它从初始状态开始,逐层地向前搜索,直到找到目标状态。

在八数码问题中,广度优先搜索会先尝试所有可能的一步移动,然后再尝试两步移动,依此类推,直到找到解决方案。

与深度优先搜索相比,广度优先搜索可以保证找到最短路径的解决方案。

然而,广度优先搜索的时间复杂度较高,尤其是在搜索空间较大时。

因此,在实际应用中,广度优先搜索可能不太适合解决八数码问题。

4. 算法三:A*算法A*算法是一种启发式搜索算法,它在搜索过程中利用了问题的启发信息,以提高搜索效率。

在八数码问题中,A*算法会根据每个状态与目标状态之间的差异,选择最有可能的移动方式。

A*算法通过综合考虑每个状态的实际代价和启发式估计值,来评估搜索路径的优劣。

通过选择最优的路径,A*算法可以在较短的时间内找到解决方案。

然而,A*算法的实现较为复杂,需要合适的启发函数和数据结构。

八数码实验报告

八数码实验报告

八数码实验报告实验名称:八数码实验目的:通过使用搜索算法和启发式算法,解决八数码问题,深入理解搜索算法原理和应用。

实验环境:使用Python语言进行编程实现,操作系统为Windows。

实验过程:1. 定义八数码问题的状态和目标状态,分别以列表的形式表示。

* 初始状态:[2, 8, 3, 1, 6, 4, 7, 0, 5]* 目标状态:[1, 2, 3, 8, 0, 4, 7, 6, 5]2. 实现深度优先搜索算法,运行程序得到结果。

通过深度优先搜索算法,得到了八数码问题的解法。

但是,由于深度优先搜索算法过于盲目,搜索时间过长,而且容易陷入无解状态,因此需要改进算法。

3. 改进算法——广度优先搜索。

在深度优先搜索的基础上,改用广度优先搜索算法,实现代码如下:```def bfs(start, target):queue = [(start, [start])]seen = {tuple(start)}while queue:node, path = queue.pop(0)for move, i in direction.items():new_node = [j for j in node]if i not in range(0, 9):continuenew_node[0], new_node[i] = new_node[i], new_node[0] if tuple(new_node) in seen:continueif new_node == target:return path + [new_node]seen.add(tuple(new_node))queue.append((new_node, path + [new_node]))```4. 改进算法——A*算法。

在广度优先搜索的基础上,使用A*算法进行优化。

进行了以下改进:* 引入估价函数,加快搜索速度;* 遍历过程中对结点进行评估,保留最优的结点。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验报告一、实验问题八数码问题求解二、实验软件编程语言或其它编程语言三、实验目的1. 熟悉人工智能系统中的问题求解过程;2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用;3. 熟悉对八数码问题的建模、求解及编程语言的应用。

四、实验数据及步骤(一、)实验内容八数码问题:在3×3的方格棋盘上,摆放着1到8这八个数码,有1个方格是空的,其初始状态如图1所示,要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。

2 83 1 2 31 4 8 47 6 5 7 6 5(a) 初始状态 (b) 目标状态图 1 八数码问题示意图(二、)基本数据结构分析和实现1.结点状态我采用了struct Node数据类型typedef struct _Node{int digit[ROW][COL];int dist; 价函数值int index; 生器函数定义的发生器函数由以下的四种操作组成:(1)将当前状态的空格上移Node node_up;Assign(node_up, index);的搜索策略经过分析,8数码问题中可采用的搜速策略共有:1.广度优先搜索、2.深度优先搜索、2.有界深度优先搜索、4.最好优先搜索、5.局部择优搜索,一共五种。

其中,广度优先搜索法是可采纳的,有界深度优先搜索法是不完备的,最好优先和局部择优搜索法是启发式搜索法。

实验时,采用了广度(宽度)优先搜索来实现。

(三、)广度(宽度)优先搜索原理1. 状态空间盲目搜索——宽度优先搜索其基本思想是,从初始节点开始,向下逐层对节点进形依次扩展,并考察它是否为目标节点,再对下层节点进行扩展(或搜索)之前,必须完成对当层的所有节点的扩展。

再搜索过程中,未扩展节点表OPEN中的节点排序准则是:先进入的节点排在前面,后进入的节点排在后面。

其搜索过程如图(1)所示。

图2、宽度优先搜索示意图2. 宽度优先算法如下:步1 把初始结点S0放入OPEN表中步2 若OPEN表为空,则搜索失败,问题无解步3 取OPEN表中最前面的结点N放在CLOSE表中,并冠以顺序编号n步4 若目标结点Sg=N,则搜索成功,问题有解步5 若N无子结点,则转步2步6 扩展结点N,将其所有子结点配上指向N的放回指针,依次放入OPEN表的尾部,转步23.宽度优先算法流程图图3、宽度优先算法流程图4.8数码难题用宽度优先搜索所生成的搜索树如图4。

搜索树上的所有节点都标记它们所对应的状态描述,每个节点旁边的数字表示节点扩展的顺序(按顺时针方向移动空格)。

图中有26个节点,也就是源程序运行结果。

6 7 8 9 10 11 12 1314 15 16 17 18 19 20 21 22 23 24 25 26图4.八数码题宽度优先搜索树五、实验结果及分析上机试验时,,经多次程序调试,最后得一下结果。

此结果所得节点(状态图)很多,可知宽度优先搜索的盲目性很大,当目标节点距离初始节点较远时,就会产生大量的无用节点,搜索效率低。

但是,只要问题有解,用宽度优先搜索总可以找到它的解。

图5.程序运行结果六、结论人工智能搜索可分为盲目搜索和启发式搜索。

盲目搜索算法有宽度优先算法、深度优先算法(有界深度优先算法),启发式搜索算法有A算法、A*算法。

本实验采用的是宽度优先(广度优先)算法,这种算法是按预定的控制策略进行,在搜素的过程中所获得的信息不用来改进控制策略。

由于搜索总是按预定的路线进行,没有考虑问题本身的特性,这种缺乏问题求解的针对性,需要进行全方位的搜索,而没有选择最优的搜索路径。

所以图4宽度优先搜索树及程序运行结果图5得到的节点(状态图)很多,而解路径为,其它节点是没有用的节点,搜索效率很低。

通过这次实验更加熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法及计算机语言对常用数据结构如链表、队列等的描述应用。

学到了不少知识。

七、源程序及注释#include <iostream>#include <ctime>#include <vector>using namespace std;const int ROW = 3;价函数值int index; ist != MAXNUM)return false;}return true;}bool isEqual(int index, int digit[][COL]) igit[i][j] != digit[i][j]) return false;}return true;}ostream& operator<<(ostream& os, Node& node){for (int i = 0; i < ROW; i++) {for (int j = 0; j < COL; j++)os << [i][j] << ' ';os << endl;}return os;}void PrintSteps(int index, vector<Node>& rstep_v)ndex; while (index != 0){(node_v[index]);index = node_v[index].index;}for (int i = () - 1; i >= 0; i--)igit[i][j];}int GetMinNode() ist == MAXNUM)continue;else if ((node_v[i].dist + node_v[i].dep) < dist) { loc = i;dist = node_v[i].dist + node_v[i].dep;}}return loc;}bool isExpandable(Node& node){for (int i = 0; i < (); i++) {if (isEqual(i, )return false;}return true;}int Distance(Node& node, int digit[][COL]) {int distance = 0;bool flag = false;for(int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++)for (int k = 0; k < ROW; k++) {for (int l = 0; l < COL; l++) {if [i][j] == digit[k][l]) {distance += abs(i - k) + abs(j - l); flag = true;break;}elseflag = false;}if (flag)break;}return distance;}int MinDistance(int a, int b){return (a < b a : b);}void ProcessNode(int index){int x, y;bool flag;for (int i = 0; i < ROW; i++) {for (int j = 0; j < COL; j++) {if (node_v[index].digit[i][j] == 0) {x =i; y = j;flag = true;break;}else flag = false;}if(flag)break;}Node node_up;Assign(node_up, index);ep + 1;(node_up);}}Node node_down;Assign(node_down, index);ep + 1;(node_down);}}Node node_left;Assign(node_left, index);ep + 1;(node_left);}}Node node_right;Assign(node_right, index);ep + 1;(node_right);}}node_v[index].dist = MAXNUM;}int main() ." << endl;clock_t start = clock();while (1){if (isEmptyOfOPEN()){cout << "Cann't solve this statement!" << endl; return -1;}else{int loc; << endl;break;}elseProcessNode(loc);}}return 0;}十五数码问题的截图(对行和列数进行修改):。

相关文档
最新文档