人工智能实验-八数码问题

实验一 采用状态空间法求解八数码问题（4学时）

一、 实验要求

八数码难题也称九宫问题，它是在3×3的方格棋盘上，分别放置了表有数字1、2、3、4、5、6、7、8的八张牌，初始状态S0，目标状态Sg，如下图所示,要求通过空格来移动八张牌使得棋盘由初始状态到达目标状态。移动规则为：每次只能将与空格（上下左右）相邻的一个数字平移到空格中。实验要求应用广度优先搜索策略寻找从初始状态到目标状态的解路径，编程语言为C系列语言。

初始状态的排列：283104765 Y= 0+1+1+0+0+4+5+5+5=21 奇排列

目标状态的排列：283104675 Y=0+1+1+0+0+4+5+6+5=22 偶排列

2	8	3
1		4
7	6	5

s0

2	8	3
1		4
6	7	5

sg

二、数据结构

定义结点 node 由以下成员组成： 数组 a[3][3]存储当前结点中 303 个空格内的数字；4 个 node 指针 u, d, l, r 分别指向当前结点向上下左右 4 个方向移动后新成立的结点， 若在某个方向上无法移动， 则相应的指针指向 NULL；指针 p指向当前结点的父结点，找到目标结点后可沿着 p 指针逐层向上生成解决步骤。

typedef struct node

{

int a[3][3];

node *u;

node *d;

node *l;

node *r;

node *p;

}

void search （node * &h）

{

queue *front, *rear;

queue *qq,*Qtemp,*Qfront;

node *tu,*td,*tl,*tr;

node *np;

int temp;

front=new queue;

};

结点 queue 用来组成队列， 定义其由以下成员组成： 指针 data 指向的 node 结点中保存着九宫图的排列及 5 个指针， 指针 next 指向队列中的下一个结点。

typedef struct queue

{

Node *data;

queue *next;

};

三、广度优先搜索

广度优先搜索的基本思想是：

从初始结点 h 开始， 逐层地对结点进行扩展并考察它是否为目标结点，若不是目标结点， 则放入待考察队列中； 在第 n 层的结点没有全部扩展并考察之前， 不对第 n+1 层的结点进行扩展。 队列中的结点总是按进入的先后顺序排列， 先进入的结点排在前面， 后进入的排在后面。其搜索过程如下：

（1） 初始化结点 h 放入队列中， 队头指针 front=h；

（2） 若 front==NULL， 则问题无解， 退出；

（3） 取出队头结点 front， n=front， front 指向队列中的下

一个结点；

（4） 考察结点 n 是否为目标结点， 若是， 则问解求得，

退出；

（5） 考察结点 n 在上下左右四个方向上是否可扩展，

将其可扩展的子结点放入队尾， 然后转步骤 2。

八数码问题的实现，基本上的主要框架是lrj书上的。只是做了一点点改变，打印了路径而已

上面是老师布置的东西，不过我发现我和老师布置的没有啥关系

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

const int maxn = 362880; ///最多9！个情况
int path[maxn];
typedef int state [9];
state st[maxn],goal;  ///状态数组，所有状态都保存在这个里面
int dist [maxn];
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
int ss;
///对于同一个结点判重
///将状态转化为9位的十进制数，然后根据stl里面set的唯一元素性质来判断是否到过这一步
set<int>vis;
void init() { vis.clear(); }
int try_to_insert(int s)
{
int v=0;
for(int i=0;i<9;i++) v=v*10+st[s][i];
if(vis.count(v)) return 0;
vis.insert(v);
return 1;
}
///输出函数，递归记录下走的步数然后将其输出来
void print()
{
//printf("21\n");
int way[100000],temp=0;

while (path[ss]!=ss) {
way[temp]=ss;
temp++;
ss=path[ss];
}

for (int x=temp-1;x>=0;x--){
ss=way[x];
for (int i=0;i<9;i++) {
if (i%3==0) puts ("");
printf ("%d ",st[ss][i]);
}
puts ("");
}
}
///判断是否有解的函数，按照逆序数的关系求解
///两个for，依次枚举一个数和它后面的数，比较求逆序数
bool judge()
{
int sum1=0;
int sum2=0;
for (int i=0;i<9;i++){
if (st[1][i]==0) continue;
for (int j=i+1;j<9;j++){
if (st[1][j]==0) continue;
if (st[1][i]>st[1][j]) sum1++;
}
}
for (int i=0;i<9;i++){
if (goal[i]==0) continue;
for (int j=i+1;j<9;j++){
if (goal[j]==0) continue;
if (goal[i]>goal[j]) sum2++;
}
}
if(sum1%2==sum2%2)
return true;
return false;
}
///深度优先搜索函数，利用二维数组记录下走的状态，通过Set比较，然后记录
int bfs()
{
init();
path[1]=1;
int front=1,rear = 2;  ///不使用下标0，因为0被当做不存在
while (front < rear){
state &s = st [front];
if (memcmp(goal,s,sizeof(s))==0) {   ///比较
return front;
}
int z;
for (z=0;z<9;z++) if (!s[z]) break;  ///找到0的位置
//printf ("%d\n",z);
int x=z/3,y=z%3;
for (int d=0;d<4;d++){ ///化成3x3的方格，然后移动方向
//puts("f");
int newx=x+dx[d];
int newy=y+dy[d];
int newz=newx*3+newy; ///退回1一行数列，然后记录
//printf ("%d %d\n",x,y);
if (newx>=0&&newx<3&&newy>=0&&newy<3){
state & t=st[rear];
memcpy (&t,&s,sizeof (s));  ///复制，拓展一个新的结点
t[newz] = s[z];
t[z]=s[newz];
//dist[rear]=dist[front]+1;
if (try_to_insert (rear)) {  ///若插入成功，修改队尾指针
path[rear]=front;
rear++;
}
}
}
front++;  ///拓展完成后修改队首的指针
}
return 0; ///失败
}

int main ()
{
for (int i=0;i<9;i++) scanf ("%d",&st[1][i]); ///起始状态
for (int i=0;i<9;i++) scanf ("%d",&goal[i]); ///目标状态
if(judge())
{
int ans = bfs();
ss=ans;
print();
//if (ans>0) printf ("%d\n",dist[ans]);
}
else printf("没有解\n");
return 0;
}