ZOJ 1217 eight

八数码，双广、A*都超时了（可能是写得不好），IDA*通过了；

在POJ上是16MS（和双广一样，A* 60MS左右），HDOJ上是800MS左右（双广是500MS），ZOJ上只有IDA*没超时（2480MS）。

# include <stdio.h>
# include <math.h>
# include <string.h>

# define MIN(x, y) ((x)<(y) ? (x):(y))

# define N 9
# define DIR_N 4
# define INF 0x7fffffff
# define MAX_DEPTH 1000
# define SIZE 3

char solved;
char start[N], goal[N];
char cur[N];

int bound;
const char md[] = {'u', 'l', 'r', 'd'};
const short int dir[][2] = {{-1,0}, {0,-1}, {0,1}, {1,0}};
char path[MAX_DEPTH];

void solve(void);
char read(char *s);
int IDAstar(void);
char bool_inv(char *s);
int heu(void);
int dfs(int zero_pos, int depth, char direction);

int main()
{
    int i;
    
    for (i = 0; i < N-1; ++i)
        goal[i] = i + 1;
    goal[N-1] = 0;
    while (read(start))
    {
        memcpy(cur, start, N);
        solve();
    }
    
    return 0;
}

void solve()
{
    int i, depth;

    if (bool_inv(start) != bool_inv(goal)) puts("unsolvable");
    else
    {
        memset(path, -1, sizeof(path));
        depth = IDAstar();
        for (i = 0; path[i]!=-1; ++i)
        {
            putchar(md[path[i]]);
        }
        putchar('\n');
    }
}

char read(char *s)
{
    char c[5];
    int i;

    if (EOF == scanf("%s", c)) return 0;
    else s[0] = (c[0]=='x' ? 0:c[0]-'0');
    for (i = 1; i < N; ++i)
    {
        scanf("%s", c);
        s[i] = (c[0]=='x' ? 0:c[0]-'0');
    }
    
    return 1;
}

int IDAstar(void)
{
    int i;

    solved = 0;
    bound = heu();

    for (i = 0; start[i] && i < N; ++i) ;

    while (!solved && bound<100)
    {
        bound = dfs(i, 0, -10);
    }

    return bound;
}

int dfs(int pos, int depth, char d)
{
    int h, i, nx, ny, npos, nbound, t;

    h = heu();

    if (depth+h > bound) return depth+h;
    if (h == 0)
    {
       /* printf("depth = %d.\n", depth); */
        solved = 1;
        return depth;
    }

    nbound = INF;
    for (i = 0; i < DIR_N; ++i)
    {
        if (i+d == DIR_N-1) continue;
        nx = pos/SIZE + dir[i][0];
        ny = pos%SIZE + dir[i][1];
        if (0<=nx && nx<SIZE && 0<=ny && ny<SIZE)
        {
            path[depth] = i;
            npos = nx*SIZE + ny;
            cur[pos] = cur[npos]; cur[npos] = 0;     /* pos -> npos */
            t = dfs(npos, depth+1, i);
            if (solved) return t;
            nbound = MIN(nbound, t);
            cur[npos] = cur[pos]; cur[pos] = 0;
        }
    }
    return nbound;
}

int heu(void)            /* return heu(cur_state) */
{
    char ch;
    int i, j, ret;

    ret = 0;
    for (i = 0; i < N; ++i)
    {
        ch = goal[i];
        if (ch == 0) continue;
        for (j = 0; j < N; ++j)
        {
            if (ch == cur[j])
            {
                ret = ret + abs(i/SIZE-j/SIZE) + abs(i%SIZE-j%SIZE);
            }
        }
    }

    return ret;
}

char bool_inv(char *s)
{
    char ch, ret;
    int i, j;

    ret = 0;
    for (i = 0; i < N-1; ++i)
    {
        if ((ch = s[i]) == 0) continue;
        for (j = i+1; j < N; ++j)
        {
            if (s[j] && s[j]<ch) ret = 1 - ret;
        }
    }

    return ret;
}