八数码问题（状态空间搜索）--《算法入门经典》

状态空间搜索一般是找到一条从初始状态到最终状态的一条最优路径，可以归结为隐式图的搜索问题，图中的节点就是在搜索过程中的状态。

八数码问题

在九宫格中填满1~8个数码，给出初始的九宫格和最终的状态，问最小移动步数，若无法到达输出-1

分析

可以吧八数码问题归结为图上的最短路问题，这样就可以用最短路求解了，而搜到的状态就是图上的节点。
主算法

const int maxstate = 1000000;
typedef int State[9];//状态
State st[maxstate],goal;
int dist[maxstate];//最小移动步数
int fa[maxstate];//父节点路径
const int dx[] = {-1,1,0,0,};
const int dy[] = {0,0,-1,1,};

/*广搜*/
int bfs()
{
    init_lookup_table();
    int front = 1;
    dist[front] =0;
    fa[front] = 0;
    int rear = 2;
    while(frontif(memcmp(goal,s,sizeof(s))== 0)return front;
        int z;//空格位置
        for (z = 0 ; z<9 ; ++z)if(!s[z])break;
        int x = z/3,y = z%3;
        for(int d = 0 ;d<4 ; ++d)
        {
            int newx = x+dx[d];
            int newy = y+dy[d];
            int newz = newx*3+newy;
            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;
                fa[rear] = front;
                if(try_insert(rear))rear++;//查重，看当前状态是否搜到过
            }
        }
        front++;
    }
    return 0;
}

用散列对当前状态进行查重

/*散列查重*/
const int hashsize = 1000003;
int head[hashsize],next[maxstate];

void init_lookup_table(){
    memset(head,0,sizeof(head));
}

int hash(State& s)
{
    int v = 0;
    for(int i=0 ; i<9 ; ++i)v = v*10+s[i];
    return v%hashsize;
}

int try_insert(int s)
{
    int h = hash(st[s]);
    int u = head[h];
    while(u)
    {
        if(memcmp(st[u],st[s],sizeof(st[s])) == 0)return 0;
        u = next[u];
    }

    /*数组链表*/
    next[s] = head[h];
    head[h] = s;
    return 1;
}