八数码（A*）

第一道A*，照着A*的框架写的，不是很理解A*，写的也很长，中间有些标记的不太理解，去掉标记在POJ提交通过了，还是没理解A*的思想；

犯了个低级错误：在判断新状态 0 的位置（nx, ny）是否越界时，应该是0 =< nx < 3，结果写成了0<= nx <=3，还叫LJ大牛一块查，最后终于给发现了；

在写 A* 之前以为 A* 会省不少空间（扩展的节点相比 BFS 少很多），实际上却开了两个大数组： f[] 和 g[]，一下子感觉也挺浪费的，时间上感觉快了很多，我测试的几组都是0MS，在POJ上提交是64MS；

两周以前就决心花几天时间搞八数码和十五数码（主要是想学学A*），结果一下子就过了十几天，八数码的还是马马虎虎，十五数码目前只能寄希望与IDA*，还想想一下八数码的构造方法（感觉分治的思想可能会用上，虽然分治法行不通）。

# include <cstdio>
# include <queue>
# include <cstring>
# include <cmath>
/*# include <ctime>  */

# define N 9

using namespace std;

typedef struct state
{
    char a[N];
    unsigned short h; 
    unsigned int c;
} state;

typedef struct 
{
    int p;
    char d;
}path;

path p[362885];

const char md[] = {'u', 'd', 'l', 'r'};
const short int dir[][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};
const int fact[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};

unsigned short int g[362885];
unsigned short int f[362885];

struct cmp{
    bool operator()(state s1, state s2){
        return f[s1.c] > f[s2.c];
    }
};

priority_queue<state, vector<state>, cmp> Q;

int cantor(state s)
{
    char ch;
    int i, j, c, ret;
    
    ret = 0;
    for (i = 0; i < N-1; ++i)
    {
        c = 0;
        ch = s.a[i];
        for (j = i+1; j < N; ++j)
            if (s.a[j] < ch) ++c;
        ret += c*fact[8-i];
    }
    
    return ret;
}    

void set_goal(char *s, state *goal)
{
    int i;
    
    for (i = 0; i < N; ++i)
        (*goal).a[i] = s[i] - '0';
}

char bool_inv(state s)
{
    char ch, ret;
    int i, j;
    
    ret = 0;
    for (i = 0; i < N-1; ++i)
    {
        if ((ch = s.a[i]) == 0) continue;
        for (j = i+1; j < N; ++j)
            if (s.a[j] && s.a[j] < ch) ret = 1 - ret;
    }
    
    return ret;
}


int heu(state cur, state goal)                     /* Manhattan 距离， 不含 0 */
{
    char ch;
    int i, j, ret;
    
    ret = 0;
    for (i = 0; i < N; ++i)
    {
        ch = goal.a[i];
        //if (ch == 0) continue;
        for (j = 0; j < N; ++j)
        {
            if (cur.a[j] == ch)
            {
                ret += abs(j/3 - i/3) + abs(j%3 - i%3);
                break;
            }
        }
    }
    
    return ret;
}

int Astar(state start, state goal)
{
    int cc, cn, cg;
    short int i, x, y, nx, ny;
    state cur, nst;
    
    memset(g, 0, sizeof(g));
    memset(f, 0, sizeof(f));
    memset(p, 0, sizeof(p));
   /* memset(vis, 0, sizeof(vis));  */
    
    while (!Q.empty()) Q.pop();
    
    g[start.c] = 1;                                               /* 用 g[] 代替 vis[] */
    f[start.c] = start.h + 1;
   /* vis[start.c] = 1; */
    Q.push(start);
    
    while (!Q.empty())
    {
        cur = Q.top();
        Q.pop();
        /* vis[cur.c] = 2; */
        if (cur.c == goal.c) {return g[cur.c]-1;}                        /* 搜索到目标节点, 走的距离应为 g[]-1 */
        for (i = 0; cur.a[i] && i < N; ++i) ;
        x = i / 3; y = i % 3;
        for (i = 0; i < 4; ++i)
        {
            nx = x + dir[i][0]; ny = y + dir[i][1];
            if (0<=nx && nx<3 && 0<=ny && ny<3)                 /* 这里边界判断原来写成了<=3，结果差得很远 */
            {
                nst = cur;
                nst.a[x*3+y] = cur.a[nx*3+ny];
                nst.a[nx*3+ny] = 0;
                nst.c = cantor(nst);
                if (g[nst.c] == 0)
                {
                    p[nst.c].p = cur.c;
                    p[nst.c].d = md[i];
                    nst.h = heu(nst, goal);
                    g[nst.c] = g[cur.c] + 1;
                    f[nst.c] = g[nst.c] + nst.h;
                    Q.push(nst);
      /*              vis[nst.c] = 1;  */
                }
                /*
                else if (vis[nst.c] == 1 && g[nst.c] > g[cur.c]+1)
                {
                    p[nst.c].p = cur.c;
                    p[nst.c].d = md[i];
                    g[nst.c] = g[cur.c] + 1;
                    f[nst.c] = g[nst.c] + nst.h;
                    //Q.push(nst);
                }
                */
            }
        }
    }
    
    return -1;
}

void print_path(int x)
{
    if (p[x].p == 0) return ;
    print_path(p[x].p);
    putchar(p[x].d);
}

bool read(state* s)
{
    int i;
    char c[5];
    
    if (EOF == scanf("%s", c)) return false;
    else (*s).a[0] = (c[0]=='x' ? 0:c[0]-'0'); 
    for (i = 1; i < N; ++i)
    {
        scanf("%s", c);
        (*s).a[i] = (c[0]=='x' ? 0:c[0]-'0');
    }
    (*s).c = cantor(*s);

    return true;
}

void solve(state start, state goal)
{
    start.h = heu(start, goal);
    if (bool_inv(start) != bool_inv(goal)) puts("unsolvable");
    else
    {
        Astar(start, goal);                      /* 逆序剪枝后，剩下的状态一定有解 */
        print_path(goal.c);
        putchar('\n');
    }
}    

int main() 
{
    state start, goal;
    
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    // set_goal("123456780", &goal);
    goal.c = cantor(goal);
    while (read(&start))
    {
        read(&goal);
        solve(start, goal);
    }    
    
   /* printf("time cost %u ms.\n", clock()/CLOCKS_PER_SEC);  */
     
    return 0;
}

//