采用状态空间法求解八数码问题

一、 实验要求

八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。

请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或 任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。

二、 实验目标

1. 熟悉人工智能系统中的问题求解过程；
2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；
3. 熟悉对八数码问题的建模、求解及编程语言的应用。

三、 实验过程

1、 算法基本原理和流程框图；
定义结点goal，搜索中每次出现的一个棋盘都相当于一个结点goal，定义一个队列st用于保存搜索中所出现的所有棋盘结点，一个棋盘结点为队列的一个成员。
广度优先搜索的基本思想是：
从初始结点 h 开始， 逐层地对结点进行扩展并考察它是否为目标结点，若不是目标结点， 则放入待考察队列中； 在第 n 层的结点没有全部扩展并考察之前，不对第 n+1 层的结点进行扩展。 队列中的结点总是按进入的先后顺序排列， 先进入的结点排在前面， 后进入的排在后面。其搜索过程如下：
（1） 初始化结点path[1]放入队列中， 队头指针 front=path[1]；
（2） 若 front>rear，则问题无解，退出；
（3） 取出队头结点 front，s=front，front指向队列中的下一个结点；
（4） 考察结点s是否为目标结点，若是，则问解求得，退出；
（5） 考察结点 s在上下左右四个方向上是否可扩展，将其可扩展的子结点放入队尾， 然后转步骤 2。

2、 基本数据结构分析和实现；

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的唯一元素性质来判断是否到过这一步。

3、 编写程序的各个子模块实现：
（1）状态转换函数：

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;
}

（2）输出函数，递归记录步数：

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 ("");
    }
}

（3）判断是否有解的函数，按照逆序数的关系求解

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;
}

（4）广度优先搜索函数，利用二维数组记录下走的状态，通过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; ///失败
}

4、 程序运行结果，含使用的搜索算法及搜索路径等；
上机试验时，经多次程序调试，最后得一下结果。此结果所得节点（状态图）很多，可知宽度优先搜索的盲目性很大， 当目标节点距离初始节点较远时，就会产生大量的无用节点，搜索效率低。但是，只要问题有解，