八数码问题（宽搜状压）

八数码问题。 编号为1～8的8个正方形滑块被摆成3行3列（有一个格子留空），如图7-
14所示。 每次可以把与空格相邻的滑块（有公共边才算相邻）移到空格中，而它原来的位置
就成为了新的空格。 给定初始局面和目标局面（用0表示空格），你的任务是计算出最少的
移动步数。 如果无法到达目标局面，则输出-1。

宽搜以求最短路。状压以判重。

判重书上介绍了三种。我添加了一种差不多的。

搜索只是简单的宽搜，但是这个状态表示挺厉害，压缩成一个数组。

判重有编码、哈希和STL库。

编码就是把数字的数字对应到全排列的编号。

哈希是。。就是哈希加静态链表。

STL库就是简单的用set或者map判重，也最慢。

#include <cstdio>
#include <cstring>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef int state[9];
const int N = 1000000;
state st[N], goal;
int dist[N];

const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};

void init();
int bfs();
bool isetd(int);

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]);
    }
//printf("%d\n", isetd(1));
    int ans;
    if(ans = bfs()){
        printf("%d\n", dist[ans]);
    }else{
        printf("-1\n");
    }

    return 0;
}

int bfs()
{
    init();
    int f = 1, r = 2;

    while(f < r){
        state & s = st[f];

        if(memcmp(goal, s, sizeof(s)) == 0)
            return f;

        int z;
        for(z = 0; z < 9; z++){
            if(!s[z])
                break;
        }

        int x = z / 3, y = z % 3;
        for(int i = 0; i < 4; i++){
            int xx = x + dx[i], yy = y + dy[i];
            int zz = xx * 3 + yy;

            if(0 <= xx && xx < 3 && 0 <= yy && yy < 3){
                state & t = st[r];
                memcpy(&t, &s, sizeof(s));
                t[zz] = s[z];
                t[z] = s[zz];
                dist[r] = dist[f] + 1;
                if(isetd(r))
                    r++;
            }
        }

        f++;
    }
    return 0;
}
/**
bool vis[362880];
int fact[9];
void init()
{
    memset(vis, false, sizeof vis);
    fact[0] = 1;
    for(int i = 1; i < 9; i++)
        fact[i] = fact[i - 1] * i;
}

bool isetd(int s)
{
    int code = 0;

    for(int i = 0; i < 9; i++){
        int cnt = 0;
        for(int j = i + 1; j < 9; j++){
            if(st[s][j] < st[s][i]){
                cnt++;
            }
        }
        code += fact[8 - i] * cnt;
    }

    if(vis[code])
        return false;

    return vis[code] = true;
}

*/
/**
const int hashsize = 1000003;
int head[hashsize], net[N];

void init()
{
    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;
}

bool isetd(int s)
{
    int h = hash(st[s]);///hash
    int u = head[h];///lian biao tou

    while(u){
        if(memcmp(st[s], st[u], sizeof(st[u])) == 0)
            return false;
        u = net[u];
    }

    net[s] = head[h];
    head[h] = s;
    return true;
}
*/
/**
map<string, bool> mp;
void init()
{
    mp.clear();
}
bool isetd(int s)
{
    string str = "";
    for(int i = 0; i < 9; i++){
        str += ('0' + st[s][i]);
    }

    if(mp[str]){
        return false;
    }
    return mp[str] = true;
}
*/
/**
set<int> vis;
void init( ) { vis.clear( ); }
bool isetd(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 6 4 1 3 7 0 5 8
8 1 5 7 3 6 4 0 2
*/