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

最新推荐文章于 2024-03-01 15:56:47 发布

原创最新推荐文章于 2024-03-01 15:56:47 发布 · 8.1k 阅读

80 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #自然语言处理

stu 同时被 2 个专栏收录

20 篇文章

订阅专栏

C++

3 篇文章

订阅专栏

本文介绍了一种采用广度优先搜索算法解决八数码问题的方法。实验要求使用盲目搜索或启发式搜索，作者选择了广度优先搜索。通过建立状态空间，利用队列保存搜索节点，并对节点进行状态转换和判重。实验结果显示，虽然广度优先搜索能确保找到解，但当目标节点远离初始节点时，会产生大量无用节点，导致搜索效率较低。结论指出，盲目搜索缺乏问题针对性，启发式搜索如A*算法可能更优。

一、实验要求

八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
在这里插入图片描述
请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。

二、实验目标

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

三、实验过程

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、程序运行结果，含使用的搜索算法及搜索路径等；
上机试验时，经多次程序调试，最后得一下结果。此结果所得节点（状态图）很多，可知宽度优先搜索的盲目性很大，当目标节点距离初始节点较远时，就会产生大量的无用节点，搜索效率低。但是，只要问题有解，用宽度优先搜索总可以找到它的解。通过分析得到结果如下：
在这里插入图片描述

四、实验结果分析:

数码难题用宽度优先搜索所生成的搜索树如图搜索树上的所有节点都标记它们所对应的状态描述，每个节点旁边的数字表示节点扩展的顺序（按顺时针方向移动空格）。图中有 26 个节点，也就是源程序运行结果。
在这里插入图片描述

五、结论：

人工智能搜索可分为盲目搜索和启发式搜索。盲目搜索算法有宽度优先算
法、深度优先算法（有界深度优先算法），启发式搜索算法有 A 算法、 A* 算法。本实验采用的是宽度优先（广度优先）算法，这种算法是按预定的控制策略进行，在搜素的过程中所获得的信息不用来改进控制策略。由于搜索总是按预定的路线进行，没有考虑问题本身的特性，这种缺乏问题求解的针对性，需要进行全方位的搜索，而没有选择最优的搜索路径。所以图 4 宽度优先搜索树及程序运行结果图 5 得到的节点（状态图）很多 ,而解路径为 1-3-8-16-26，其它节点是没有用的节点，搜索效率很低。通过这次实验更加熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法及计算机语言对常用数据结构如链表、队列等的描述应用。学到了不少知识。

六、源程序

#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;
}
/*2 8 3 1 0 4 7 6 5
1 2 3 8 0 4 7 6 5
2 5 4 3 0 7 1 8 6
1 2 3 8 0 4 7 6 5 
*/