人工智能-八数码问题-启发式搜索

【问题描述】

以八数码问题为例，以启发式搜索方法求解给定初始状态和目标状态的最优搜索路径。

1 、设计代码的构架。

2 、定义启发式函数，使用 A* 算法，要求能正确求解出从初始状态到目标状态的移动路线。

3 、在控制台界面显示初始状态、目标状态和中间搜索步骤。

4 、在实验报告中对所采用的启发式函数作出性能分析。

 

【问题分析】

在简单的宽度优先搜索中，队列的元素排列顺序是根据进栈的先后顺序，最先进栈的排在队首。而 A* 算法就是要利用启发信息，根据估价函数值重新排序，对估价函数值小的结 点优先进行扩展，提高搜索的效率。

#include<bits/stdc++.h>
using namespace std;
vector<int>start_state,end_state;   //初态和终态
struct state{
    vector<int>now;                 //当前的状态数组
    vector<int>steps;               //当前走过的步骤记录
    int deep;                       //深度
    //启发信息=状态的深度+未在正确位置的数字个数
	bool operator < (const state &a) const{
		int x=0,y=0;
		for(int i=0;i<9;i++)
			if(now[i]!=end_state[i])x++;
		for(int i=0;i<9;i++)
			if(a.now[i]!=end_state[i])y++;
    	return deep+x<a.deep+y;
	} 
};   
int step[4]={-3,-1,1,3};            //移动路线共四种
map<vector<int>,int>vis;            //标记状态是否遍历过
int find_(vector<int>a){            //找到当前矩阵中0的位置
    for(int i=0;i<9;i++)
        if(a[i]==0)return i;
}
void print_matrix(vector<int>a){    //打印矩阵
    printf("%d %d %d\n%d %d %d\n%d %d %d\n\n",a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);
}
void print(state t){                //打印结果
    vector<int>k=start_state;
    printf("initial\n");
    print_matrix(k);
    for(int i=0;i<t.steps.size();i++){
        int index=find_(k);
        swap(k[index+t.steps[i]],k[index]);
        printf("step %d\n",i+1);
        print_matrix(k);
    }
}
bool check(int index,int k){        //判断该步是否可以移动
    if(k==-3&&(index==3||index==4||index==5||index==6||index==7||index==8))return 1;
    if(k==-1&&(index==1||index==2||index==4||index==5||index==7||index==8))return 1;
    if(k==1&&(index==0||index==1||index==3||index==4||index==6||index==7))return 1;
    if(k==3&&(index==0||index==1||index==2||index==3||index==4||index==5))return 1;
    return 0;
}
int main()
{
    for(int i=0;i<9;i++) {          //读入初态
        int x;cin>>x;
        start_state.push_back(x);
    }
    for(int i=0;i<9;i++) {          //读入终态
        int x;cin>>x;
        end_state.push_back(x);
    }
    bool flag=0;                    //标记是否到达终态
    /*     构造初始状态，加入到空队列中     */
    vector<int>k;
    state t;t.now=start_state;t.steps=k;t.deep=0;
    priority_queue<state>q;q.push(t);
    vis[start_state]=1;
    while(!q.empty()){
        t=q.top();
        if(t.now==end_state){       //判断当前队首元素是否为终态
            flag=1;
            print(t);
            break;
        }
        if(t.deep>10) break;        //深度>10,结束搜索
        else{
            int index=find_(t.now);
            for(int i=0;i<4;i++){
                if(check(index,step[i])){
                    state s;s.now=t.now;s.steps=t.steps;s.deep=t.deep+1;
                    swap(s.now[index],s.now[index+step[i]]);
                    s.steps.push_back(step[i]);
                    if(!vis.count(s.now)){
                        q.push(s);
                        vis[s.now]=1;
                    }
                }
            }
        }
        q.pop();
    }
    if(!flag)printf("no answer\n");
    return 0;
}