数据结构课设实验二：隐式图的搜索问题

一、实验内容

编写九宫重排问题的启发式搜索（A*算法）求解程序。
在3х3组成的九宫棋盘上，放置数码为1~8的8个棋子，棋盘中留有一个空格，空格周围的棋子可以移动到空格中，从而改变棋盘的布局。根据给定初始布局和目标布局，编程给出一个最优的走法序列。输出每个状态的棋盘
测试数据：初始状态：123456780 目标状态：012345678
【输入格式】
输入包含三行，每行3各整数，分别为0-8这九个数字，以空格符号隔开，标识问题的初始状态。0表示空格，例如：
2 0 3
1 8 4
7 6 5

二、实验提示

对于九宫重排问题的解决，首先要考虑是否有答案。每一个状态可认为是一个1×9的矩阵，问题即通过矩阵的变换，可以变换为目标状态对应的矩阵。由数学知识可知，可计算这两个有序数列的逆序值，如果两者都是偶数或奇数，则可通过变换到达，否则，这两个状态不可达。这样，就可以在具体解决问题之前判断出问题是否可解，从而可以避免不必要的搜索。
如果初始状态可以到达目标状态，那么采取什么样的方法呢？常用的状态空间搜索有深度优先和广度优先。广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。他的效率实在太低，甚至不可完成。由于九宫重排问题状态空间共有9!个状态，如果选定了初始状态和目标状态，有9!/2个状态要搜索，考虑到时间和空间的限制，在这里要求采用A算法求解。
A算法是启发式搜索算法，启发式搜索就是在状态空间中对每一个搜索分支进行评估，得到最好的分支，再从这个分支进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，利用当前与问题有关的信息作为启发式信息指导搜索，这些信息能够有效省略大量无谓的搜索路径，大大提高了搜索效率。
启发式搜索算法定义了一个估价函数f(n)，与问题相关的启发式信息都被计算为一定的 f(n) 的值，引入到搜索过程中。f(n) = g(n) +h(n)其中f(n) 是节点n的估价函数，g(n)是在状态空间中从初始节点到节点n的实际代价，h(n)是从节点n到目标节点最佳路径的估计代价。 在九宫重排问题中，显然g(n)就是从初始状态变换到当前状态所移动的步数，估计函数h(n)估计的是节点n到目标节点的距离，我们可以用欧几里德距离、曼哈顿距离或是两节的状态中数字的错位数来估计。

1、存储结构的定义
typedef struct node//八数码结构体
{
int nine[N][N];//数码状态
int f;//估价值
int direct;//空格移动方向
struct node *parent;//父节点
}pNode;
2、启发式搜索算法的描述：
（1）把初始节点S0 放入Open表中，f(S0)=g(S0)+h(S0);
（2）如果Open表为空，则问题无解，失败退出；
（3）把Open表的第一个节点取出放入Closed表，并记该节点为n;
（4）考察节点n是否为目标节点。若是，则找到了问题的解，成功退出；
（5）若节点n不可扩展，则转到第（2)步；
（6）扩展节点n，生成子节点ni(i=1,2,……)，计算每一个子节点的估价值f(ni) (i=1,2,……)，并为每一个子节点设置指向父节点的指针，然后将这些子节点放入Open表中；
（7）根据各节点的估价函数值，对Open表中的全部节点按从小到大的顺序重新进行排序；
（8）转到第（2）步。
启发式搜索算法的工作过程：

三、实验代码

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

struct node {
    int nine[3][3];//数码状态  
    int f;         //估价值
    int direct;     //记录深度
    node* parent;  //父节点
    node(int direct) :direct(direct) {}
    bool operator == (node& q) {          //判断两个状态对应位置元素是否完全相等
        for (int i = 0; i < 3; i++) 
        {
            for (int j = 0; j < 3; j++) 
            {
                if (nine[i][j] != q.nine[i][j])
                    return false;
            }
        }
        return true;
    }

    node& operator = (node& p) //以状态p为当前状态赋值，对应位置元素相同
{         
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                nine[i][j] = p.nine[i][j];
            }
        }
        return *this;
    }
};

int Pos[9] = { 4, 0, 1, 2, 5, 8, 7, 6, 3 };//每一位是某个数字应该在的位置所代表的数，除3和对3取余可以求出行列

void print(node* p) 
{         
    for (int i = 0; i < 3; i++) 
    {
        for (int j = 0; j < 3; j++)
            cout << "    " << p->nine[i][j] << " ";
        cout << endl;
    }
    cout << endl;
}

int geth(node& p) //计算p的h值。
{             
    int h = 0;
    for (int i = 0; i < 3; i++) 
    {
        for (int j = 0; j < 3; j++) 
            if (p.nine[i][j] != 0)
                h += abs(Pos[p.nine[i][j]] / 3 - i) + abs(Pos[p.nine[i][j]] % 3 - j);
    }
    return h;
}

int find0(node& p) 
{               
    for (int i = 0; i < 3; i++) 
        for (int j = 0; j < 3; j++) 
            if (p.nine[i][j] == 0)
                return i * 3 + j;
}

int f(node* p) //计算f()
{               
    return geth(*p) + p->direct;
}

bool cmp(node* p, node* q) //比较两个状态的f值
{       
    return f(p) > f(q);
}

vector<node*> open;         //open表
vector<node*> close;        //close表

vector<node*>::iterator look_up_dup(vector<node*>& vec, node* p) 
{
    vector<node*>::iterator it = vec.begin();
    for (; it < vec.end(); it++) 
        if ((*(*it)) == *p) 
            break;
    return it;
}

node* search(node& s) //A*算法
{      
    int deep = 0;
    open.push_back(&s);
    while (!open.empty()) 
    {
        sort(open.begin(), open.end(), cmp);//对open表中的元素进行排序
        
        node* p = open.back();
        open.pop_back();

        if (geth(*p) == 0)
            return p;           //所有数到达目标位置，搜索过程结束
        deep = p->direct + 1;

        int zeroPos = find0(*p);
        int x = zeroPos / 3;
        int y = zeroPos % 3;
        for (int i = 0; i < 4; i++) //上下左右四个方向
        {  
            int x_offset = 0, y_offset = 0;
            switch (i) 
            {
                case 0:x_offset = 0, y_offset = 1; break;   //右
                case 1:x_offset = 0, y_offset = -1; break;  //左
                case 2:x_offset = 1, y_offset = 0; break;   //上
                case 3:x_offset = -1, y_offset = 0; break;  //下
            };

            if (x + x_offset < 0 || x + x_offset >= 3 || y + y_offset < 0 || y + y_offset >= 3)
                continue;

            node* q = new node(deep);
            q->parent = p;
            *q = *p;
            q->nine[x][y] = q->nine[x + x_offset][y + y_offset];
            q->nine[x + x_offset][y + y_offset] = 0;

            bool skip = 0;
            vector<node*>::iterator dup = look_up_dup(open, q);

            if (dup != open.end()) 
            {
                if (f(q) < f(*dup)) 
                {
                    (*dup)->direct = q->direct;
                    (*dup)->parent = q->parent;
                }
                skip = 1;
            }

            dup = look_up_dup(close, q);
            if (dup != close.end()) 
            {
                if (f(q) < f(*dup)) 
                {
                    delete* dup;
                    close.erase(dup);
                    open.push_back(q);
                    skip = 1;
                }
            }

            if (!skip) {
                open.push_back(q);
            }
        }

        close.push_back(p);
    }
}

void printAn(node* p)       //输出解路径
{
    vector<node*> trace;
    while (p) 
    {
        trace.push_back(p);
        p = p->parent;
    }
    int count = 0;
    while (!trace.empty()) 
    {
        cout << "----------step" << count << "------------" << endl;
        cout << endl;
        print(trace.back());
        cout << "f:" << f(trace.back()) << "     g:" << count << "      h:" << geth(*trace.back()) << endl << endl;
        trace.pop_back();
        count++;
    }
}

int main()
{
    node p(0);
    p.nine[0][0] = 2;//设置初始状态
    p.nine[0][1] = 0;
    p.nine[0][2] = 3;
    p.nine[1][0] = 1;
    p.nine[1][1] = 8;
    p.nine[1][2] = 4;
    p.nine[2][0] = 7;
    p.nine[2][1] = 6;
    p.nine[2][2] = 5;

    p.parent = NULL;
    node* q;
    q = search(p);
    printAn(q);
    system("pause");
}

4、实验结果