实验三：A星算法求解8数码问题实验
. 实验三：A*算法求解8数码问题实验
一、 实验目的 熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。
二、 实验内容 1、 八数码问题描述 所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的。将任意摆放的数码盘（城初始状态）逐步摆成某个指定的数码盘的排列（目标状态），如图1所示
图1 八数码问题的某个初始状态和目标状态 对于以上问题，我们可以把数码的移动等效城空格的移动。如图1的初始排列，数码7右移等于空格左移。那么对于每一个排列，可能的一次数码移动最多只有4中，即空格左移、空格右移、空格上移、空格下移。最少有两种（当空格位于方阵的4个角时）。所以，问题. 就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。
2、 八数码问题的求解算法 2.1 盲目搜索 宽度优先搜索算法、深度优先搜索算法 2.2 启发式搜索 启发式搜索算法的基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。 先定义下面几个函数的含义： f*(n)=g*(n)+h*(n) (1) 式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值；h*(n)表示从当前节点n到目标节点g的最短路径的耗散值，f*(n)表示从初始节点s经过n到目标节点g的最短路径的耗散值。 评价函数的形式可定义如(2)式所示： f(n)=g(n)+h(n) (2) 其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。 利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。在A算法中，如果对所有的x， h(x)<=h*(x) (3) 成立，则称好h(x)为h*(x)的下界，它表示某种偏于保守的估计。. 采用h*(x)的下界h(x)为启发函数的A算法，称为A*算法。 针对八数码问题启发函数设计如下： f(n)=d(n)+p(n) (4) 其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为 .
g(SUC)SUC=OLD,把它添加到BESTNDOE的后继结点表中 重新确定OLD的父辈节点为BESTNODE，并修正父辈节点的g值和f值，记下g(OLD) 是 成功 SUC∈CLOSED 把SUCCESSOR放入OPEN表，添进BESTNODE的后裔表 计算f值 是 否 是 否 是 否 否 否
开始 把S放入OPEN表，记f=h OPEN=NULL? 是 失败
扩展BESTNODE,产生其后继结点SUCCESSOR 选取OPEN表上未设置过的具有最小f值的节点 BESTNODE,放入CLOSED表
BESTNODE是目标节点
建立从SUCCESSOR返回BESTNODE的指针 计算g(SUC)=g(BES)+k(BES,SUC) SUC∈OPEN . 图2 A*算法流程图 p(n)，意为放错的数码与正确的位置距离之和。 由于实际情况中，一个将牌的移动都是单步进行的，没有交换拍等这样的操作。所以要把所有的不在位的将牌，移动到各自的目标位置上，至少要移动从他们各自的位置到目标位置的距离和这么多次，所以最有路径的耗散值不会比该值小，因此该启发函数h(n)满足A*算法的条件。
3、 A*算法流程图,如图2 4、 A*算法总结 4.1，把起始状态添加到开启列表。 4.2，重复如下工作： a) 寻找开启列表中f值最低的节点，我们称它为BESTNOE b) 把它切换到关闭列表中。 c) 对相邻的4个节点中的每一个 *如果它不在开启列表，也不在关闭列表，把它添加到开启列表中。把BESTNODE作为这一节点的父节点。记录这一节点的f和g值 *如果它已在开启或关闭列表中，用g值为参考检查新的路径是否更好。更低的g值意味着更好的路径。如果这样，就把这一节点的父节点改为BESTNODE，并且重新计算这一节点的f和. g值，如果保持开启列表的f值排序，改变之后需要重新对开启列表排序。 d) 停止 把目标节点添加到关闭列表，这时候路径被找到，或者没有找到路径，开启列表已经空了，这时候路径不存在。 4.3，保存路径。从目标节点开始，沿着每一节点的父节点移动直到回到起始节点。这就是求得的路径。
5、数据结构 采用结构体来保存八数码的状态、f和g的值以及该节点的父节点；
struct Node{ int s[3][3];//保存八数码状态，0代表空格 int f,g;//启发函数中的f和g值 struct Node * next; struct Node *previous;//保存其父节点 };
6、实验结果，如图3所示 . 图3 A*算法求解八数码问题实验结果 7、源代码 //----------------------------------------------------------------------------- //代码：利用A*算法求解八数码问题。 //八数码问题的启发函数设计为：f(n)=d(n)+p(n),其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为p(n)，意为放错的数码与正确的位置距离之和。 . //后继结点的获取：数码的移动等效为空格的移动。首先判断空格上下左右的可移动性，其次移动空格获取后继结点。 //-----------------------------------------------------------------------------
#include #include #include
//八数码状态对应的节点结构体 struct Node{ int s[3][3];//保存八数码状态，0代表空格 int f,g;//启发函数中的f和g值 struct Node * next; struct Node *previous;//保存其父节点 };
int open_N=0; //记录Open列表中节点数目 //八数码初始状态 int inital_s[3][3]={ 2,8,3, 1,6,4, . 7,0,5 };
//八数码目标状态 int final_s[3][3]={ 1,2,3, 8,0,4, 7,6,5 };
//------------------------------------------------------------------------ //添加节点函数入口，方法：通过插入排序向指定表添加 //------------------------------------------------------------------------ void Add_Node( struct Node *head, struct Node *p) { struct Node *q;
if(head->next)//考虑链表为空 { q = head->next; if(p->f < head->next->f){//考虑插入的节点值比链表的第一个节点值小 p->next = head->next; . head->next = p; } else { while(q->next)//考虑插入节点x，形如a<= x <=b { if((q->f < p->f ||q->f == p->f) && (q->next->f > p->f || q->next->f == p->f)){ p->next = q->next; q->next = p; break; } q = q->next; } if(q->next == NULL) //考虑插入的节点值比链表最后一个元素的值更大 q->next = p; } } else head->next = p; }
//------------------------------------------------------------------------ . //删除节点函数入口 //------------------------------------------------------------------------ void del_Node(struct Node * head, struct Node *p ) { struct Node *q; q = head; while(q->next) { if(q->next == p){ q->next = p->next; p->next = NULL; if(q->next == NULL) return; // free(p); } q = q->next; } }
//------------------------------------------------------------------------ //判断两个数组是否相等函数入口 //------------------------------------------------------------------------ int equal(int s1[3][3], int s2[3][3])
人工智能八数码
基于A星算法解决8数码问题的编程实现一、问题描述8数码问题又称9宫问题。
在给定的33⨯棋格的9个格子内分别放从1到8互不相等的八个数，剩下的一格即为空格，此程序中空格我们用0来表示。
通常把8个符号在棋格上的排列顺序称作8数码的状态。
开始时，规则给定一个初始状态和一个目标状态，并要求被试者对棋格内的数字经过若干次移动由初始状态达到目标状态，这个过程中只有空格向附近的棋格移动，且每次只能移动一次。
如我们给定8数码的初始状态和目标状态分别如图1、2所示。
图1 初始状态图2 目标状态则要求以图1为初始状态，通过交换0和0的上、下、左、右四个方位的数字（每次只能和其中一个交换），达到图2所示目标状态。
二、算法说明根据任务要求，本文采用A*搜索算法。
1. 状态的表示在A*算法中，需要用到open表和closed表，在open表中，待扩展节点间有很严格的扩展顺序。
因此在表示当前状态的变量中，必须要有能指向下一个扩展节点的指针，以完成对open表中元素的索引。
从这一点上看，open表中的元素相互间即构成了一个线性表，因此初步选定使用结构体表示问题的状态。
如图3所示，表示问题的结构体包括表示当前节点状态的DATA和指向open 表中下一个待扩展节点的指针NEXT。
图3 结构体现在进一步考虑DATA中包括的内容：如图1、2所示，8数码问题的提出是以一个33⨯数表表示的，因此本文中采用一个33⨯的二维数组s[3][3]表示当前状态的具体信息。
另一方面，A*搜索算法是通过考察节点的代价值来决定open表的排序的，因此在表示当前状态的DATA中还应该有对当前节点代价值的描述。
根据A*算法的定义，当前节点的代价值由估价函数给出，即：=+f n d n h n()()()其中：()d n表示当前节点n在搜索树中的深度；h n是启发函数。
()本例h(n)=p(n)+w(n)其中：p(n)表示每个将牌与其目标位置之间最短距离的总和；w(n)表示不在位的将牌个数。
a星算法求解八数码问题python
a星算法求解八数码问题python一、介绍八数码问题是一种经典的智力游戏，也是人工智能领域中的经典问题之一。
在这个问题中，有一个3×3的棋盘，上面摆着1至8这8个数字和一个空格，初始状态和目标状态都已知。
要求通过移动数字，将初始状态变换成目标状态。
其中空格可以和相邻的数字交换位置。
为了解决这个问题，我们可以使用A*算法。
本文将详细介绍如何用Python实现A*算法来求解八数码问题。
二、A*算法简介A*算法是一种启发式搜索算法，常用于寻找最短路径或最优解等问题。
它基于Dijkstra算法，并加入了启发式函数来加速搜索过程。
在A*算法中，每个节点都有两个估价值：g值和h值。
g值表示从起点到该节点的实际代价，h值表示从该节点到目标节点的估计代价。
启发式函数f(n) = g(n) + h(n) 表示从起点到目标节点的估计总代价。
A*算法采用优先队列来保存待扩展的节点，并按照f(n)值从小到大排序。
每次取出队头元素进行扩展，并将扩展出来的新节点按照f(n)值插入队列中。
当扩展出目标节点时，算法结束。
三、八数码问题的状态表示在八数码问题中，每个状态都可以表示为一个3×3的矩阵。
我们可以用一个一维数组来表示这个矩阵，其中0表示空格。
例如，初始状态可以表示为[2, 8, 3, 1, 6, 4, 7, 0, 5]，目标状态可以表示为[1, 2, 3, 8, 0, 4, 7, 6, 5]。
四、A*算法求解八数码问题的步骤1.将初始状态加入优先队列中，并设置g值和h值为0。
2.从队头取出一个节点进行扩展。
如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
3.对于每个新节点，计算g值和h值，并更新f(n)值。
如果该节点已经在优先队列中，则更新其估价值；否则，将其加入优先队列中。
4.重复第2步至第3步直到搜索结束。
五、Python实现以下是用Python实现A*算法求解八数码问题的代码：```import heapqimport copy# 目标状态goal_state = [1,2,3,8,0,4,7,6,5]# 启发式函数：曼哈顿距离def h(state):distance = 0for i in range(9):if state[i] == 0:continuerow = i // 3col = i % 3goal_row = (state[i]-1) // 3goal_col = (state[i]-1) % 3distance += abs(row - goal_row) + abs(col - goal_col)return distance# A*算法def A_star(start_state):# 初始化优先队列和已访问集合queue = []visited = set()# 将初始状态加入优先队列中，并设置g值和h值为0heapq.heappush(queue, (h(start_state), start_state, 0))while queue:# 取出队头元素进行扩展f, state, g = heapq.heappop(queue)# 如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
人工智能实验报告完整版八数码+验证解读
把数码问题就是把一串数字变为下边这个样子:1 2 38 0 47 6 5实现方法1.过程表示源代码：#include<stdio.h>static int style[9]={1,2,3,6,7,4,5,8,0};//输入的数码//2,5,4,3,0,7,1,8,63,2,1,8,0,4,7,6,5 1,0,4,2,7,3,8,5,61,0,3,8,2,4,7,6,5static int arrayStep41[6]={5,4,3,6,7,8};//第四步和第六步共用的数组，所以设为全局量static int arrayStep71[4]={3,6,7,4};static int local;// 空格的地点int i,j;// 所用到的变量int number=0;// 记录挪动步数void print();void step1();void step2();void step3();void step4();void step5();void step6();void step7();void step8();void step9();void exchange(int x,int y);void judge();void judge()// 判断空格地点{number = 0;for(i=0;i<9;i++){if(style[i]==0){local=i;return;}}}void exchange(int x,int y)// 互换两个数{int temp;print();temp=style[x];style[x]=style[y];style[y]=temp;local=y;number++;}void step1(){int arrayStep11[5]={3,0,1,2,5};int arrayStep12[6]={6,7,8,5,2,1};if((style[2]!=0)&&style[2]!=1)return;else{if(local==2){if(style[1]==1)exchange(2,5);elseexchange(2,1);return;}else{if(local==4){exchange(4,1);i=2;while(local!=5){exchange(arrayStep11[i],arrayStep11[i+1]);i++;}return;}for(i=0;i<3;i++){if(arrayStep11[i]==local){while(local!=5){exchange(arrayStep11[i],arrayStep11[i+1]);i++;}return;}}for(i=0;i<4;i++){if(arrayStep12[i]==local){while(local!=1){exchange(arrayStep12[i],arrayStep12[i+1]);i++;}return;}}}}return;}void step2(){int arrayStep21[8]={0,3,6,7,8,5,4,1};for(i=0;i<8;i++){if(arrayStep21[i]==local){while(style[0]!=1){exchange(arrayStep21[i%8],arrayStep21[(i+1)%8]);i++;}break;}}}void step3(){int arrayStep31[8]={2,1,4,3,6,7,8,5};for(i=0;i<8;i++){if(arrayStep31[i]==local){while(style[1]!=2){exchange(arrayStep31[i%8],arrayStep31[(i+1)%8]);i++;}break;}}}void step4(){for(i=0;i<6;i++){if(arrayStep41[i]==local){while((style[4]!=3)){exchange(arrayStep41[i%6],arrayStep41[(i+1)%6]);i=(i+1)%6;}while(local!=3){exchange(arrayStep41[i%6],arrayStep41[(i+5)%6]);i=(i+5)%6;}break;}}}void step5(){int arrayStep51[9]={3,0,1,4,5,2,1,0,3};i=0;do{exchange(arrayStep51[i],arrayStep51[i+1]);i++;}while(local!=3);}void step6(){for(i=0;i<6;i++){if(arrayStep41[i]==local){while(style[5]!=4){exchange(arrayStep41[i%6],arrayStep41[(i+1)%6]);i++;}if(local==8)exchange(8,7);break;}}return;}void step7(){for(i=0;i<4;i++){if(arrayStep71[i]==local){while(style[4]!=5){exchange(arrayStep71[i%4],arrayStep71[(i+1)%4]);i=(i+1)%4;}while(local!=3){exchange(arrayStep71[i%4],arrayStep71[(i+3)%4]);i=(i+3)%4;}break;}}}void step8(){int arrayStep81[13]={3,0,1,2,5,4,7,8,5,2,1,0,3};i=0;do{exchange(arrayStep81[i],arrayStep81[i+1]);i++;}while(local!=3);}void step9(){for(i=0;i<4;i++){if(arrayStep71[i]==local){while(style[7]!=6){exchange(arrayStep71[i%4],arrayStep71[(i+1)%4]);i=(i+1)%4;}while(local!=4){exchange(arrayStep71[i%4],arrayStep71[(i+3)%4]);i=(i+3)%4;}break;}}}void print(){for(j=0;j<9;j++){if(style[j]==0)printf(" \t");elseprintf("%d\t",style[j]);if((j+1)%3==0)printf("\n");}printf("************ %d ***********\n",number);}void loop(){printf(" 请输入数码：\n");for(i=0;i<9;i++)scanf("%d",&style[i]);judge();step1();step2();step3();if(style[2]!=3){step4();step5();}step6();if(style[8]!=5){step7();step8();}step9();print();if(!((style[3]==8)&&(style[6]==7)))printf(" 用书上所给算法来看此数码错误！\n"); }void main(){while(1)loop();}2.深度优先实现/***************说明 ***********************用宽度优先搜寻算法实现八数码问题******************************************/#include<iostream>#include<stdio.h>#include<fstream>#include<stdlib.h>#include "string.h"#include "assert.h"#include "windows.h"using namespace std;int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int startKey = 0,endKey = 0,equalKey = 1,tempSpace;struct node *openHead,*open; //open 表struct node *closedHead,*closed; //closed 表struct node *tempNode; //临节气点struct node *answer; // 找到的路径int num = 0;struct node{int style[9];struct node *next;struct node *father;};void updateData()//更新要判断数据{int i;printf(" 请输入八数码原始状态：\n");for(i = 0;i < 9;i++)scanf("%d",&wholeStyle[i]);printf(" 请输入八数码最后状态：\n");for(i = 0;i < 9;i++)scanf("%d",&standard1[i]);}void judge1(struct node *head)// 判断空格地点{for(i = 0;i < 9;i++){if(head->style[i] == 0){local = i;return;}}}int judge2(struct node *head) // 判断能否与标准八数码相等，不相等返回值为0 {for(i = 0;i < 9;i++){if(head->style[i] != standard1[i]){if((i == 3)&&(head->style[3] == standard1[6]));else if((i == 6)&&(head->style[6] == standard1[3]));elsereturn 0;}}return 1;}void judge3() // 判断重生成的八数码能否就是最后状态或许在open、 closed 表中出现{if(judge2(tempNode))endKey = 1;else{while(openHead->next->next->style[0] != 9){for(i = 0;i < 9;i++){if(openHead->next->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(equalKey)// 不相等openHead = openHead->next;elsebreak;}openHead = open->next;if(equalKey)// 不相等{while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i++){if(closedHead->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(!equalKey)// 相等break;elseclosedHead = closedHead->next;}closedHead = closed->next;}if(equalKey)// 不相等{open->next = tempNode;tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;}}}void print(struct node *temp)// 输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)printf(" \t");elseprintf("%d\t",temp->style[j]);if((j + 1) % 3 == 0)printf("\n");}}void write2txt(){ofstream out("F:\\out_details.txt",ios::app);if( out.fail() ){cerr<<" 未找到文件 "<<endl;}out<<"第 "<<++num<<" 步 \n";out<<"open table ： \n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table ： \n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void main(){//updateData();// 输入八数码数据for(i = 0;i < 9;i++)//判断初始状态能否已经为最后状态{if(wholeStyle[i] == standard1[i]);else{if((i == 3)&&(wholeStyle[i] == standard1[6]));else if((i == 6)&&(wholeStyle[i] == standard1[3]));else{startKey = 1;break;}}}if(!startKey){printf(" 不用判断！ \n");return;}printf(" 要判断！ \n");openHead = new node();open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;closedHead = new node();closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;while(open->style[0] != 9)//当open表不为空时向来循环{judge1(openHead->next);if(local % 3 > 0)// 右移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local > 2)// 下移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local % 3 < 2)// 左移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local < 6)// 上移{equalKey = 1;tempNode = new node();//tempNode = malloc(sizeof(struct node));for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;closed->next = openHead->next; // 把 open 的标头增添到closed 表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();}open->next = tempNode;// 把找到的新节点增添到open 表中tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;closed 表中closed->next = openHead->next; //把 open 的标头增添到openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();answer = new node();tempNode = new node();tempNode = open;while(tempNode->style[0] != 9)// 将结果路径存于answer{answer = tempNode;tempNode = tempNode->father;tempNode->next = answer;}num = 0;while(answer->next->style[0] != 9)//输出answer{printf("***********第%d 步***********\n",num++);print(answer);answer = answer->next;printf("\n");}printf("***********第 %d 步 ***********\n",num++);print(answer);if(answer->style[3] != standard1[3])printf("\n!! 输入的八数码不合法，不可以从初始状态到最后状态 \n\n\n\n");return;}3.宽度优先：/***************说明 ***********************用宽度优先搜寻算法实现八数码问题******************************************/#include<iostream>#include<stdio.h>#include<fstream>#include<stdlib.h>#include "string.h"#include "assert.h"#include "windows.h"using namespace std;int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int startKey = 0,endKey = 0,equalKey = 1,tempSpace; struct node *openHead,*open; //open 表struct node *closedHead,*closed; //closed 表struct node *tempNode; //临节气点struct node *answer; // 找到的路径int num = 0;struct node{int style[9];struct node *next;struct node *father;};void updateData()//更新要判断数据{int i;printf(" 请输入八数码原始状态：\n");for(i = 0;i < 9;i++)scanf("%d",&wholeStyle[i]);printf(" 请输入八数码最后状态：\n");for(i = 0;i < 9;i++)scanf("%d",&standard1[i]);}void judge1(struct node *head)// 判断空格地点{for(i = 0;i < 9;i++){if(head->style[i] == 0){local = i;return;}}}int judge2(struct node *head) // 判断能否与标准八数码相等，不相等返回值为0{for(i = 0;i < 9;i++){if(head->style[i] != standard1[i]){if((i == 3)&&(head->style[3] == standard1[6]));else if((i == 6)&&(head->style[6] == standard1[3]));elsereturn 0;}}return 1;}void judge3() // 判断重生成的八数码能否就是最后状态或许在open、 closed 表中出现{if(judge2(tempNode))endKey = 1;else{while(openHead->next->next->style[0] != 9){for(i = 0;i < 9;i++){if(openHead->next->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(equalKey)// 不相等openHead = openHead->next;elsebreak;}openHead = open->next;if(equalKey)// 不相等{while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i++){if(closedHead->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(!equalKey)// 相等break;elseclosedHead = closedHead->next;}closedHead = closed->next;}if(equalKey)// 不相等{open->next = tempNode;tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;}}}void print(struct node *temp)// 输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)printf(" \t");elseprintf("%d\t",temp->style[j]);if((j + 1) % 3 == 0)printf("\n");}}void write2txt(){ofstream out("F:\\out_details.txt",ios::app);if( out.fail() ){cerr<<" 未找到文件 "<<endl;}out<<"第 "<<++num<<" 步 \n";out<<"open table ： \n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table ： \n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void main(){//updateData();// 输入八数码数据for(i = 0;i < 9;i++)//判断初始状态能否已经为最后状态{if(wholeStyle[i] == standard1[i]);else{if((i == 3)&&(wholeStyle[i] == standard1[6]));else if((i == 6)&&(wholeStyle[i] == standard1[3]));else{startKey = 1;break;}}}if(!startKey){printf(" 不用判断！ \n");return;}printf(" 要判断！ \n");openHead = new node();open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;closedHead = new node();closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;while(open->style[0] != 9)//当open表不为空时向来循环{judge1(openHead->next);if(local % 3 > 0)// 右移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local > 2)// 下移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local % 3 < 2)// 左移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local < 6)// 上移{equalKey = 1;tempNode = new node();//tempNode = malloc(sizeof(struct node));for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;closed->next = openHead->next;// 把 open 的标头增添到closed 表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();}open 表中open->next = tempNode;// 把找到的新节点增添到tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;closed 表中closed->next = openHead->next; //把 open 的标头增添到openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();answer = new node();tempNode = new node();tempNode = open;while(tempNode->style[0] != 9)//将结果路径存于answer{answer = tempNode;tempNode = tempNode->father;tempNode->next = answer;}num = 0;while(answer->next->style[0] != 9)//输出answer{printf("***********第%d 步***********\n",num++);print(answer);answer = answer->next;printf("\n");}printf("***********第 %d 步 ***********\n",num++);print(answer);if(answer->style[3] != standard1[3])printf("\n!! 输入的八数码不合法，不可以从初始状态到最后状态\n\n\n\n");return;}4.A 算法/***************说明 ************************* A 算法实现八数码问题********************************************/#include<iostream>#include<fstream>#include<iomanip>using namespace std;void print(struct node *temp);int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int tempSpace;struct node *openHead,*open; //open 表struct node *closedHead,*closed; //closed 表struct node *tempNode; //临节气点struct node *answer; // 找到的路径int num = 0;bool endKey;struct node{int depth;int judgement_based;int style[9];struct node *next;struct node *father;};void updateData()//更新要判断数据{int i;cout<<" 请输入八数码原始状态："<<endl;for(i = 0;i < 9;i++)cin>>wholeStyle[i];cout<<" 请输入八数码最后状态："<<endl;for(i = 0;i < 9;i++)cin>>standard1[i];}int judge1(struct node *head)// 判断空格地点{for(i = 0;i < 9;i++){if(head->style[i] == 0)return i;}}int evaluation_function(struct node *head) //计算不在正确地点的点的个数{int not_correct_position = 0;for(i = 0;i < 9;i++)if((head->style[i] != 0)&&(head->style[i] != standard1[i]))not_correct_position++;return not_correct_position;}void print(struct node *temp)// 输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)cout<<" \t";elsecout<<temp->style[j]<<"\t";if((j + 1) % 3 == 0)cout<<endl;}}void write2txt()// 将过程记录到文本文档中{ofstream out("F:\\out_details4.txt",ios::app);if( out.fail() ){cerr<<" 未找到文件 "<<endl;}out<<"第 "<<++num<<" 步 \n";out<<"open table ： \n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<" 估值： ";out<<openHead->next->judgement_based<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table ： \n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"深度："<<closedHead->next->depth<<"估值："<<closedHead->next->judgement_based<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void basic_exchange_oper()// 每一次基本的互换都要进行的动作{if(judge1(tempNode) != judge1(closed->father))// 当重生成节点的空格地点与 closed 父亲节点的空格地点不相等{tempNode->father = closed; // 重生成节点的指向它的父亲节点 tempNode->depth =closed->depth + 1;// 深度加 1 tempNode->judgement_based =evaluation_function(tempNode) + tempNode->depth;//计算估值while(openHead->next->style[0] != 9){if(tempNode->judgement_based > openHead->next->judgement_based){openHead = openHead->next;}else{tempNode->next = openHead->next;openHead->next = tempNode;openHead = open->next;return;}}//插入的值比最后一个还大进行下边的操作openHead = open->next;// 先恢复表头不然 Head 指向为最后一个open->next = tempNode;tempNode->next = openHead;open = open->next;return;}}void main(){//updateData();// 输入八数码数据openHead = new node();//初始化 open 表open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;open->depth = 0;open->judgement_based = evaluation_function(open) + open->depth;// 这行能够不写closedHead = new node(); //初始化 closed 表closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;int min_judgement1 = open->judgement_based;while(open->style[0] != 9)//当open表不为空时向来循环{//updateData();// 输入八数码数据write2txt();closed->next = openHead->next;//把 open 表中第一组八数码移到closed 表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;if(openHead->next->style[0] == 9)// 假如是第一次则 open 暂时指向openHead open = openHead;if(closed->judgement_based == closed->depth)// 判断新移进 closed 表中的八数码的 f 值能否等于它的层数{cout<<"succeed!"<<endl;write2txt();answer = new node();while(closed->style[0] != 9)// 将结果存于answer 表中{answer = closed;closed = closed->father;closed->next = answer;}num = 0;while(answer->style[0] != 9)//控制台显示步骤{cout<<"****** 第 "<<num++<<" 步 ***********\n";print(answer);cout<<endl;answer = answer->next;}return;}else //假如 closed 表末的八数码是最后状态则拓展新的八数码{local = judge1(closed);if(local % 3 > 0)// 右移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local < 6)// 上移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local > 2)// 下移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local % 3 < 2)// 左移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}}}cout<<"false!"<<endl;}神经网络实验群神经网络实验一、实验目的：理解反向流传网络的构造和原理，掌握反向流传算法对神经元的训练过程，认识反向流传公式。
基于A星算法的8数码问题求解方案设计（1）
基于A星算法的8数码问题求解⽅案设计（1）⼀、问题描述8数码问题⼜称9宫问题，与游戏“华容道”类似。
意在给定的33棋格的8个格⼦内分别放⼀个符号，符号之间互不相同，余下的⼀格为空格。
并且通常把8个符号在棋格上的排列顺序称作8数码的状态。
开始时，规则给定⼀个初始状态和⼀个⽬标状态，并要求被试者对棋格内的符号经过若⼲次移动由初始状态达到⽬标状态，这个过程中只有空格附近的符号可以朝空格的⽅向移动，且每次只能移动⼀个符号。
为⽅便编程和表⽰，本⽂中8个格⼦内的符号分别取1—8的8个数字表⽰，空格⽤0表⽰。
并给定8数码的初始状态和⽬标状态分别如图1、2所⽰。
图1 初始状态图2 ⽬标状态则要求以图1为初始状态，通过交换0和0的上、下、左、右四个⽅位的数字（每次只能和其中⼀个交换），达到图2所⽰⽬标状态。
⼆、实验⽬的熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利⽤A*算法求解N数码难题，理解求解流程和搜索顺序。
三、实验任务1）实现类似于如图所⽰N数码难题演⽰程序。
2）⽤你所熟悉的程序语⾔实现，可以B/S实现，也可以C/S实现四、算法设计根据任务要求，本⽂采⽤A*搜索算法。
但要在计算机上通过编程解决该问题，还应当解决该问题在计算机上表⽰的⽅式，并设计合适的启发函数，以提⾼搜索效率。
①状态的表⽰在A*算法中，需要⽤到open表和closed表，特别是在open表中，待扩展节点间有很严格的扩展顺序。
因此在表⽰当前状态的变量中，必须要有能指向下⼀个扩展节点的指针，以完成对open表中元素的索引。
从这⼀点上看，open表中的元素相互间即构成了⼀个线性表，因此初步选定使⽤结构体表⽰问题的状态。
如图3所⽰，表⽰问题的结构体包括表⽰当前节点状态的DATA和指向open 表中下⼀个待扩展节点的指针NEXT。
图3 结构体现在进⼀步考虑DATA中包括的内容：如图1、2所⽰，8数码问题的提出是以⼀个33数表表⽰的，因此本⽂中采⽤⼀个33的⼆维数组s[3][3]表⽰当前状态的具体信息。
启发式搜索A星算法的八数码实现报告
1. 请简述人工智能概念于何时何地由何人第一次正式提出？答：1956年夏，在美国的达特茅斯（Dartmouth ）学院，由McCarthy （斯坦福大学，MIT ）、Minsky （哈佛大学数学和神经学家）、Lochester （IBM 公司）、Shannon （贝尔实验室）四人共同发起，邀请IBM 公司的Moore 、Samuel ，MIT 的Selfridge 、Solomonff ，还有Simon 、Newell 等人参加学术讨论班，在一起共同学习和探讨用机器模拟智能的各种问题，在会上，经McCarthy 提议，决定使用“人工智能”一词来概括这个研究方向。
这次具有历史意义的会议标志着人工智能这个学科的正式诞生。
2.当前人工智能有哪些学派？简述它们在人工智能理论上有何不同之处？a.符号主义: 起源于数理逻辑 基于逻辑推理 认知是符号的处理过程,推理是问题求解过程(核心是知识表示) 无法表示不确知事物和常识问题 Nilssonb.连接主义: 起源于仿生学 基于神经网络 思维是神经元的连接活动而不是符号运算过程(学习算法和网络结构) 用大量非线性并行处理器模拟大脑 Newellc.行为主义: 起源于控制论 基于”感知-行动” 直接利用机器对环境发出作用后环境对作用者的响应为原型(有限状态机,不表示不推理) 能应付复杂环境 MIT Brooks 3.八数码问题初始状态定义估价函数: f(x) = d(x) + h(x),其中：d(x)表示节点x 的深度，h(x)表示节点x 的棋局与目标节点棋局距离的度数。
(1) 使用以上估价函数进行全局择优搜索，列出头三步搜索中的OPEN 表和CLOSED 表全局择优搜索过程如下：(1) 把初始节点S0放入OPEN 表，f(S0)。
(2) 如果OPEN 表为空，则问题无解，退出。
(3) 把OPEN 表的第一个节点(记为节点n)取出放入CLOSED 表。
(4) 考察节点n 是否为目标节点。
八数码实验报告人工智能课设报告
学生实验报告实验课名称：人工智能实验名称: 八数码专业名称：计算机科学与技术班级：学号：学生姓名：教师姓名：2010 年10 月20日一．实验内容用OPEN表和CLOSED表解决搜索问题。
二．实验题目采用启发式算法（如A*算法）求解八数码问题。
三．实验要求1.必须使用OPEN表和CLOSED表。
2.明确给出问题描述。
系统初始状态。
目标状态和启发式函数。
3.除了初始状态以外，至少搜索四层。
4.给出解路径（解图）。
四．实验过程①问题：初始状态到目标状态是否可解如何判断？答：实验过程自己给出的初始状态使用A*算法求解，并不是所有的初始状态都可解到达目标状态。
因为八数码问题其实是0~9的一个排列，而排列有奇排列和偶排列，从奇排列不能转化为偶排列或者相反。
例如：函数f(s)表示s前比s 小的数字的数目（s则当f(a8)+f(a7)+……+f(a1)为偶数时才能重排成，所以嘛,上面那个有解的.②问题描述：在3X3的九宫格棋盘上，摆有8个将牌，每一个将牌都刻有1~8数码中的某一个数码。
棋盘中留有一个空格，允许周围的某一个将牌向空格移动，这样通过移动将牌就可以不断地改变将牌的布局。
这种游戏的求解的问题是：给定一种处世的将牌布局或结构和一个目标的布局，问如何移动将牌，实现从从初始状态到目标状态的转变。
下面给出初始状态和目标状态：初始状态：目标状态：评价函数f(n)形式为：f(n)=g(n)+h(n),其中g(n)是节点所处的深度，h(n)是启发式函数，这里启发式函数h(n)表示“不在位”的将牌个数，这时f(n)可估计出通向目标结点的希望的程度。
注意：移动规则为左-→上→右→下。
③搜索过程：如下图-1为八数码问题的搜索树：因此可得解路径：S(4)→B(4)→D(5)→E(5)→I(5)→K(5)→L(5).④得到OPEN表和CLOSED表结论：由以上分析,可以从CLOSED表中可知从初始状态到结束状态的搜索路径为：S0→S2→S5→S9→S11→S12.五、实验体会通过本次实验又将课本内容熟悉了一遍，而且通过互联网了解了更多的关于八数码问题，如读过网上用VC++编写八数码问题的源代码，虽然理解不是很深，但基本思想也是有所体会；同时也对广度优先搜索算法，深度优先算法，双向广度优先算法及A*算法有更深的掌握。
西电人工智能大作业八数码问题
人工智能关于八数码问题摘要：八数码问题是人工智能中一个很典型的智力问题。
本文以状态空间搜索的观点讨论了八数码问题，给出了八数码问题的C++算法与实现的思想，分析了A 算法的可采纳性等及系统的特点。
关键词九宫重排，状态空间，启发式搜索，A 算法1引言九宫重排问题是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下一个位置为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始状态转化为目标状态。
状态转换的规则：空格四周的数移向空格，我们可以看作是空格移动，它最多可以有４个方向的移动，即上、下、左、右。
九宫重排问题的求解方法，就是从给定的初始状态出发，不断地空格上下左右的数码移至空格，将一个状态转化成其它状态，直到产生目标状态。
一、问题描述1.1 待解决问题的解释八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
1.2 问题的搜索形式描述（4要素）初始状态：8个数字将牌和空格在九宫格棋盘上的所有格局组成了问题的状态空间。
其中，状态空间中的任一种状态都可以作为初始状态。
后继函数：通过移动空格（上、下、左、右）和周围的任一棋子一次，到达新的合法状态。
目标测试：比较当前状态和目标状态的格局是否一致。
路径消耗：每一步的耗散值为1，因此整个路径的耗散值是从起始状态到目标状态的棋子移动的总步数。
二、 A*算法介绍2.1 搜索算法一般介绍不管哪种搜索，都统一用这样的形式表示：搜索的对象是一个图，它面向一个问题，不一定有明确的存储形式，但它里面的一个结点都有可能是一个解（可行解），搜索的目的有两个方面，或者求可行解，或者从可行解集中求最优解。
人工智能A星算法解决八数码难题程序代码
#include "Stdio.h"#include "Conio.h"#include "stdlib.h"#include "math.h"void Copy_node(struct node *p1,struct node *p2);void Calculate_f(int deepth,struct node *p);void Add_to_open(struct node *p);void Add_to_closed(struct node *p);void Remove_p(struct node *name,struct node *p);int Test_A_B(struct node *p1,struct node *p2);struct node * Search_A(struct node *name,struct node *temp); void Print_result(struct node *p);struct node // 定义8数码的节点状态{int s[3][3]; //当前8数码的状态int i_0; //当前空格所在行号int j_0; //当前空格所在列号int f; //当前代价值int d; //当前节点深度int h; //启发信息，采用数码"不在位"距离和struct node *father; //指向解路径上该节点的父节点struct node *next; //指向所在open或closed表中的下一个元素} ;struct node s_0={{2,8,3,1,6,4,7,0,5},2,1,0,0,0,NULL,NULL}; //定义初始状态struct node s_g={{1,2,3,8,0,4,7,6,5},1,1,0,0,0,NULL,NULL}; //定义目标状态struct node *open=NULL; //建立open表指针struct node *closed=NULL; //建立closed表指针int sum_node=0; //用于记录扩展节点总数//***********************************************************//********************** **********************//********************** 主函数开始**********************//********************** **********************//***********************************************************void main(){int bingo=0; //定义查找成功标志，bingo=1，成功struct node s; //定义头结点sstruct node *target,*n,*ls,*temp,*same; //定义结构体指针Copy_node(&s_0,&s); //复制初始状s_0态给头结点s Calculate_f(0,&s); //计算头结点的代价值Add_to_open(&s); //将头结点s放入open表while(open!=NULL) //只要open表不为空，进行以下循环{n=open; //n指向open表中当前要扩展的元素ls=open->next;Add_to_closed(n);open=ls; //将n指向的节点放入closed表中if(Test_A_B(n,&s_g)) //当前n指向节点为目标时，跳出程序结束；否则，继续下面的步骤{bingo=1;break;}elseif(n->j_0>=1) //空格所在列号不小于1,可左移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0-1==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝n指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0-1]; //空格左移temp->s[temp->i_0][temp->j_0-1]=0;temp->j_0--;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end左移if(n->j_0<=1) //空格所在列号不大于1,可右移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0+1==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0+1]; //空格右移temp->s[temp->i_0][temp->j_0+1]=0;temp->j_0++;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end右移if(n->i_0>=1) //空格所在列号不小于1,上移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0-1&&temp->j_0==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0-1][temp->j_0];//空格上移temp->s[temp->i_0-1][temp->j_0]=0;temp->i_0--;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end上移if(n->i_0<=1) //空格所在列号不大于1,下移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0+1&&temp->j_0==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0+1][temp->j_0]; //空格下移temp->s[temp->i_0+1][temp->j_0]=0;temp->i_0++;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end下移}if(bingo=1) Print_result(n); //输出解路径else printf("问题求解失败！");}//主函数结束//************************************************************************* //********************** ********************** //********************** 计算某个节点状态的代价值********************** //********************** ********************** //*************************************************************************void Calculate_f(int deepth,struct node *p){int i,j,temp;temp=0;for(i=0;i<=2;i++) //计算所有"不在位"数码的距离和{for(j=0;j<=2;j++){if((p->s[i][j])!=(s_g.s[i][j]))temp++;}}p->h=temp;p->f=deepth+p->h;}//*************************************************************************//********************** **********************//********************** 添加p指向的节点到open表中********************** //********************** **********************//*************************************************************************void Add_to_open(struct node *p){struct node *p1,*p2;p1=open; //初始时p1指向open表首部p2=NULL;if(open==NULL) //open表为空时，待插入节点即为open表第一个元素，open 指向该元素{p->next=NULL;open=p;}else //open表不为空时，添加待插入节点，并保证open表代价递增的排序{while(p1!=NULL&&p->f>p1->f){p2=p1; //p2始终指向p1指向的前一个元素p1=p1->next;}if(p2==NULL) //待插入节点为当前open表最小{p->next=open;open=p;}else if(p1==NULL) //待插入节点为当前open表最大{p->next=NULL;p2->next=p;}else //待插入节点介于p2、p1之间{p2->next=p;p->next=p1;}}}//***************************************************************************//********************** **********************//********************** 添加p指向的节点到closed表中**********************//********************** **********************//***************************************************************************void Add_to_closed(struct node *p){if(closed==NULL) //closed表为空时，p指向节点为closed表第一个元素，closed{p->next=NULL;closed=p;}else //closed表不为空时，直接放到closed表首部{p->next=closed;closed=p;}}//************************************************************************************* *************//********************************************//********************** 在open表或closed表中搜索和temp指向的节点相同的节点**********************//********************************************//*************************************************************************************struct node * Search_A(struct node *name,struct node *temp){struct node *p1;p1=name; //p1指向open表或closed表while(p1!=NULL){if(Test_A_B(p1,temp)) //找到相同的节点，返回该节点地址return p1;elsep1=p1->next;}return NULL;}//************************************************************************************* **********//********************************************//********************** 判断两个节点状态是否相同，相同则返回1，否则返回0 **********************//********************************************//************************************************************************************* **********int Test_A_B(struct node *p1,struct node *p2){int i,j,flag;flag=1;for(i=0;i<=2;i++)for(j=0;j<=2;j++){if((p2->s[i][j])!=(p1->s[i][j])) { flag=0; return flag; }else ;}return flag;}//******************************************************************************//********************** **********************//********************** 从open表或closed表删除指定节点********************** //********************** **********************//******************************************************************************void Remove_p(struct node *name,struct node *p){struct node *p1,*p2;p1=NULL;p2=NULL;if(name==NULL) //如果name指向的链表为空，则不需要进行删除return;else if(Test_A_B(name,p)&&name->f==p->f) //指定节点为name指向的链表的第一个元素{open=name->next;name->next=NULL;return;}else{p2=name;p1=p2->next;while(p1){if(Test_A_B(p1,p)&&p1->f==p->f) //找到指定节点{p2->next=p1->next;return;}else{p2=p1; //p2始终指向p1指向的前一个元素p1=p1->next;}}return;}}//************************************************************************************* *//********************************************//********************** 将p1指向的节点状态拷贝到p2指向的节点中**********************//********************************************//************************************************************************************* *void Copy_node(struct node *p1,struct node *p2){int i,j;for(i=0;i<=2;i++){for(j=0;j<=2;j++){ p2->s[i][j]=p1->s[i][j]; }}p2->i_0=p1->i_0;p2->j_0=p1->j_0;p2->f=p1->f;p2->d=p1->d;p2->h=p1->h;p2->next=p1->next;p2->father=p1->father;}//*********************************************************** //********************** ********************** //********************** 输出结果********************** //********************** ********************** //***********************************************************void Print_result(struct node *p){struct node *path[100];struct node *temp,*temp_father;int i,j,k;for(i=0;i<=99;i++) //初始化路径指针数组path[i]=0;temp=p;printf("总共扩展%d 个节点\n",sum_node);printf("总共扩展%d 层\n",temp->d);printf("解路径如下：\n");for(i=p->d;i>=0;i--) //存储解路径上各节点的地址{path[i]=temp;temp=temp->father;}for(k=0;k<=p->d;k++) //输出解路径{temp=path[k]; //建立节点指点指针printf("第%d步",temp->d);if(k-1>=0) //输出移动策略{temp_father=path[k-1];if(temp->i_0<temp_father->i_0) printf("->上移\n");if(temp->i_0>temp_father->i_0) printf("->下移\n");if(temp->j_0<temp_father->j_0) printf("->左移\n");if(temp->j_0>temp_father->j_0) printf("->右移\n");}elseprintf("\n");printf("当前节点状态为：\n");for(i=0;i<=2;i++){for(j=0;j<=2;j++){printf("%d ",temp->s[i][j]);}printf("\n");}printf("\n");}}THANKS !!!致力为企业和个人提供合同协议，策划案计划书，学习课件等等打造全网一站式需求欢迎您的下载，资料仅供参考。
八数码问题人工智能实验报告
基于人工智能的状态空间搜索策略研究——八数码问题求解（一）实验软件或编程语言或其它编程语言（二）实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
（三）需要的预备知识1. 熟悉或编程语言或者其它编程语言；2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法；3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用；4. 熟悉计算机常用人机接口设计。
（四）实验数据及步骤1. 实验内容八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
437465图1 八数码问题示意图请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。
2. 实验步骤（1）分析算法基本原理和基本流程；程序采用宽度优先搜索算法，基本流程如下：（2）确定对问题描述的基本数据结构，如 Open 表和 Closed 表等；（3）编写算符运算、目标比较等函数；（4）编写输入、输出接口；（5）全部模块联调；（6）撰写实验报告。
（五）实验报告要求所撰写的实验报告必须包含以下内容：1. 算法基本原理和流程框图；2. 基本数据结构分析和实现；3. 编写程序的各个子模块，按模块编写文档，含每个模块的建立时间、功能、输入输出参数意义和与其它模块联系等；4. 程序运行结果，含使用的搜索算法及搜索路径等；5. 实验结果分析；6. 结论；7. 提供全部源程序及软件的可执行程序。
附：实验报告格式一、实验问题二、实验目的三、实验原理四、程序框图五、实验结果及分析六、结论。
用A算法解决八数码问题
用A*算法解决八数码问题一、 题目：八数码问题也称为九宫问题。
在3×3的棋盘，有八个棋子，每个棋子上标有1至8的某一数字，分歧棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要解决的问题是：任意给出一个初始状态和一个目标状态，找出一种从初始转酿成目标状态的移动棋子步数最少的移动步调。
二、 问题的搜索形式描述状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操纵符：用来发生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标规划。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索战略，用尽可能少的步数得到上图的目标状态算法介绍三、解决方案介绍1.A*算法的一般介绍A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。
对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即 ()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--；这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制约，节点距目标点近，h 值小，f 值相对就小，能包管最短路的搜索向终点的方向进行。
明显优于盲目搜索战略。
A star 算法在静态路网中的应用2.算法伪代码创建两个表，OPEN 表保管所有已生成而未考察的节点，CLOSED 表中记录已访问过的节点。
算起点的估价值，将起点放入OPEN 表。
while(OPEN!=NULL){从OPEN表中取估价值f最小的节点n;if(n节点==目标节点){break;}for(当前节点n 的每个子节点X){算X的估价值;if(X in OPEN){if( X的估价值小于OPEN表的估价值){把n设置为X的父亲;更新OPEN表中的估价值; //取最小路径的估价值}}if(X inCLOSE){if( X的估价值小于CLOSE表的估价值){把n设置为X的父亲;更新CLOSE表中的估价值;把X节点放入OPEN //取最小路径的估价值}}if(X not inboth){把n设置为X的父亲;求X的估价值;并将X拔出OPEN表中; //还没有排序}}//end for将n节点拔出CLOSE表中;依照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。