人工智能-八数码问题

八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8的八块正方形数码牌任意地放在一块3×3的数码盘上。放牌时要求不能重叠。于是，在3×3的数码盘上出现了一个空格。现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘逐步摆成某种特殊的排列。

状态表示：用一个二维数组a[3][3]表示数码盘上的某种布局，a[i][j]表示数码盘上第（i+1）行第（j+1）列的数码牌，空格则用零来表示，为了编程方便用结构体jiedian表示搜索中生成的每个结点，存储结构采用的是单链表，形成一个类似线性表的数据结构，结构体jiedian中成员C[3][3]表示数码盘上数码牌的某种状态，成员quanzhi表示A*算法中针对C[3][3]计算出的w(n)，成员parent表示该结点的父结点，成员next表示在链表存储结构中该结点的下一个节点，成员layer表示该结点所处的层数。

编程规则：
空格周围的棋子可以向空格移动，换种角度看，也就是空格可以向上下左右四个方向移动，假设空格所处的位置为（a,b）,则有四条规则：
（1）如果a-1>=0,则空格可以向上移动，数码牌的布局改变如下c[a][b]= c[a-1][b]，
c[a-1][b]=0;
（2）如果b-1>=0,则空格可以向左移动，数码牌的布局改变如下c[a][b]= c[a][b-1]，
c[a][b-1]=0;
（3）如果a+1<=2,则空格可以向下移动，数码牌的布局改变如下c[a][b]= c[a+1][b]，
c[a+1][b]=0;
（4）如果b+1<=2,则空格可以向右移动，数码牌的布局改变如下c[a][b]= c[a][b+1]，
c[a][b+1]=0;
A*搜索算法：取g(n)=d(n)，h(n)=w(n)，其中w(n)表示以目标为基准，结点n的状态中每一个数码牌与其目标位置之间的距离（不考虑夹在其间的数码牌）的总和，由于从结点n转换成目标结点至少需要w(n)步，所以对任意n，恒有w(n) ≤h*(n)。
简单程序说明：程序开始运行时，初始化两个链表（假设为a和b），一个存储未扩展的结点（相当于Open表，假设为a），一个存储已经扩展的结点（相当于Closed表，假设为b），首先将初始结点放在链表a的第一个位置，然后取出链表a的第一个元素，根据编程规则看可以对该元素对应的结点进行哪些扩展（即0数码牌可以怎么移动），如果能进行某种扩展，则生成新的对应结点（设为e），标记该结构体对应的成员变量C[3][3]，quanzhi，parent，next，layer，然后查找在a中是否有某个结点的C值与该结点相同，如果没有，则在b中查找是否有某个结点的C值与该结点相同，如果也没有，则在链表中找到插入该结点的位置然后插入该结点e（a中按结点的quanzhi+layer由小到大排序，如果quanzhi+layer相同，则先生成的结点放在前面），如果在b中有某个结点（设为f）C值与该结点相同，则计算结点f的layer，比较e的layer与f的layer的大小，如果e的layer小于f的layer，也在链表中找到插入该结点的位置然后插入该结点e，如果e的layer大于等于f的layer，则不插入该结点e，如果a中有某个结点（假设为g）的C值与该结点相同，则计算结点g的layer，如果g的layer小于等于e的layer，则不插入该结点e，如果g的layer大于e的layer，则先删除结点g，然后在链表中找到插入该结点的位置然后插入该结点e，在一次扩展完成后，删除链表a的第一个结点，把它放入链表b中，循环进行，直到链表a的第一个元素的C值与目标相同（即移动结束）。
附：源代码
#include<stdio.h>
#include<malloc.h>
#include<process.h>
#include<math.h>
struct jiedian
{
int c[3][3];
int quanzhi;
jiedian *parent;
jiedian *next;
int layer;
};
typedef jiedian * lianbiao;
void fuzhi(int c[3][3],int d[3][3])
{
for(int i1=0;i1<=2;i1++)
{
for(int j1=0;j1<=2;j1++)
{
c[i1][j1]=d[i1][j1];
}
}
}
void Initlianbiao(lianbiao &l)
{
l=(lianbiao)malloc(sizeof(jiedian));
if(!l)
exit(1);
l->parent=NULL;
l->next=NULL;
}
int LocateWeizhi(lianbiao a,jiedian b)
{
int i=0;
lianbiao p=a->next;
while(p)
{
i++;
if((p->quanzhi+p->layer)>(b.quanzhi+b.layer))
return i;
if((p->quanzhi+p->layer)==(b.quanzhi+b.layer))
{
int j=i+1;
return j;
}
p=p->next;
}
return (i+1);
}
int Insertjiedian(lianbiao a,int i,jiedian b)
{
int j=0;
lianbiao s,p=a;
while(p&&j<i-1)
{
j++;
p=p->next;
}
s=(lianbiao)malloc(sizeof(jiedian));
fuzhi(s->c,b.c);
s->layer=b.layer;
s->parent=b.parent;
s->quanzhi=b.quanzhi;
s->next=p->next;
p->next=s;
return 1;
}
int DeleteJiedian(lianbiao a,int i)
{
int j=0;
lianbiao q,p=a;
while(p&&j<i-1)
{
j++;
p=p->next;
}
if(!p->next||j>i-1)
return 0;
q=p->next;
p->next=q->next;
return 1;
}
int compare1(int c[3][3],int d[3][3])
{
for(int i1=0;i1<=2;i1++)
{
for(int j1=0;j1<=2;j1++)
{
if(d[i1][j1]!=c[i1][j1])
return 0;
}
}
return 1;
}
bool find0(lianbiao a,jiedian b)
{
lianbiao p=a->next;
while(p)
{
if(compare1(p->c,b.c)==1)
return true;
p=p->next;
}
return false;
}
int find(lianbiao a,jiedian b)
{
int i=0;
lianbiao p=a->next;
while(p)
{
i++;
if(compare1(p->c,b.c)==1)
return p->layer;
p=p->next;
}
return 1000;
}
int find1(lianbiao a,jiedian b)
{
int i=0;
lianbiao p=a->next;
while(p)
{
i++;
if(compare1(p->c,b.c)==1)
return i;
p=p->next;
}
}
int compare2(int c[3][3],int d[3][3])
{
int distance=0;
for(int i = 0; i<3; i++)
for (int j = 0;j<3; j++)
for (int k = 0; k<3; k++)
for (int l = 0; l<3; l++)
if (c[i][j] == d[k][l]&&c[i][j]!=0)
distance +=abs(i - k)+abs(j - l);
return distance;
}
void print(int w[][3],int i,int j)
{
for(int i0=0;i0<=i;i0++)
{
printf("/n");
for(int j0=0;j0<=j;j0++)
printf("%d",w[i0][j0]);
}
}
void shuchu(lianbiao a)
{
jiedian shuzu[100];
lianbiao b=a->next;
int u=0;
while(b)
{
u=u+1;
fuzhi(shuzu[u].c,b->c);
b=b->parent;

}
for(int i=u;i>=1;i--)
{
print(shuzu[i].c,2,2);
printf("/n");
if(i!=1)
printf("ˇ%d",u-i+1);
}
printf("/n");
}
int main()
{

int a[3][3];
int i;
int j;
int i0;
int j0;
int top=1;
for(i=0;i<=2;i++)
{
printf("/n");
for(j=0;j<=2;j++)
scanf("%d",&a[i][j]);
}
int b[3][3]={{1,2,3},{8,0,4},{7,6,5}};
int d[3][3];
int shang[3][3],xia[3][3],zuo[3][3],you[3][3];
lianbiao r;
Initlianbiao(r);
lianbiao l;
Initlianbiao(l);
jiedian a0;
fuzhi(a0.c,a);
a0.layer=0;
a0.quanzhi=compare2(a0.c,b);
a0.parent=NULL;
a0.next=NULL;
Insertjiedian(l,1,a0);
static int h=1;
while(compare1(l->next->c,b)!=1)
{
lianbiao aa=l->next;
jiedian bb=*aa;
Insertjiedian(r,h,bb);
h++;
int m,m0;
fuzhi(d,aa->c);
fuzhi(shang,aa->c);
fuzhi(xia,aa->c);
fuzhi(zuo,aa->c);
fuzhi(you,aa->c);
for(i=0;i<=2;i++)
{
for(j=0;j<=2;j++)
{
if(d[i][j]==0)
{
i0=i;
j0=j;
break;
}
}
}
if(i0-1>=0)
{

shang[i0][j0]=shang[i0-1][j0];
shang[i0-1][j0]=0;
jiedian shang1;
fuzhi(shang1.c,shang);
shang1.parent=aa;
shang1.layer=(aa->layer)+1;
shang1.quanzhi=compare2(shang1.c,b);
shang1.next=NULL;
if(find0(l,shang1)==false)
{
if(find0(r,shang1)==false)
{
m=LocateWeizhi(l,shang1);
Insertjiedian(l,m,shang1);
}
else
{
int y=find(r,shang1);
if(shang1.layer<y)
{
m0=LocateWeizhi(l,shang1);
Insertjiedian(l,m0,shang1);
}

}
}
else
{
int x=find(l,shang1);
if(x<=shang1.layer)
{
}
else
{
int k=find1(l,shang1);
DeleteJiedian(l,k);
m=LocateWeizhi(l,shang1);
Insertjiedian(l,m,shang1);
}
}
}
if(j0-1>=0)
{
zuo[i0][j0]=zuo[i0][j0-1];
zuo[i0][j0-1]=0;
jiedian zuo1;
fuzhi(zuo1.c,zuo);
zuo1.parent=aa;
zuo1.layer=aa->layer+1;
zuo1.quanzhi=compare2(zuo,b);
if(find0(l,zuo1)==false)
{
if(find0(r,zuo1)==false)
{
m=LocateWeizhi(l,zuo1);
Insertjiedian(l,m,zuo1);
}
else
{
int y=find(r,zuo1);
if(zuo1.layer<y)
{
m0=LocateWeizhi(l,zuo1);
Insertjiedian(l,m0,zuo1);
}

}
}
else
{
int x=find(l,zuo1);
if(x<=zuo1.layer)
{
}
else
{
int k=find1(l,zuo1);
DeleteJiedian(l,k);
m=LocateWeizhi(l,zuo1);
Insertjiedian(l,m,zuo1);
}
}
}
if(i0+1<=2)
{
xia[i0][j0]=xia[i0+1][j0];
xia[i0+1][j0]=0;
jiedian xia1;
fuzhi(xia1.c,xia);
xia1.parent=aa;
xia1.layer=aa->layer+1;
xia1.quanzhi=compare2(xia,b);
if(find0(l,xia1)==false)
{
if(find0(r,xia1)==false)
{
m=LocateWeizhi(l,xia1);
Insertjiedian(l,m,xia1);
}
else
{
int y=find(r,xia1);
if(xia1.layer<y)
{
m0=LocateWeizhi(l,xia1);
Insertjiedian(l,m0,xia1);
}

}
}
else
{
int x=find(l,xia1);
if(x<=xia1.layer)
{
}
else
{
int k=find1(l,xia1);
DeleteJiedian(l,k);
m=LocateWeizhi(l,xia1);
Insertjiedian(l,m,xia1);
}
}
}
if(j0+1<=2)
{
you[i0][j0]=you[i0][j0+1];
you[i0][j0+1]=0;
jiedian you1;
fuzhi(you1.c,you);
you1.parent=aa;
you1.layer=aa->layer+1;
you1.quanzhi=compare2(you,b);
if(find0(l,you1)==false)
{
if(find0(r,you1)==false)
{
m=LocateWeizhi(l,you1);
Insertjiedian(l,m,you1);
}
else
{
int y=find(r,you1);
if(you1.layer<y)
{
m0=LocateWeizhi(l,you1);
Insertjiedian(l,m0,you1);
}

}
}
else
{
int x=find(l,you1);
if(x<=you1.layer)
{
}
else
{
int k=find1(l,you1);
DeleteJiedian(l,k);
m=LocateWeizhi(l,you1);
Insertjiedian(l,m,you1);
}
}
}
DeleteJiedian(l,1);
}
shuchu(l);
return 0;
}