UVa 10181 15Puzzle Problem

题目链接不好找：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1122

用的 IDA*，跑了6.536s，时限是45s（刚看了627个人通过，我是第515名……，排行榜比较恐怖啊，见下图）

这道题的逆序剪枝和八数码不同，具体参考这篇文章：http://mathworld.wolfram.com/15Puzzle.html
1A！

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

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

# define SIZE 4
# define N SIZE*SIZE
# define DIR_N 4
# define INF 0x7fffffff
# define MAX_DEPTH 1000

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);
void read(char *s);
int IDAstar(void);
char inv_judge(char *s);
int heu(void);
int dfs(int zero_pos, int depth, char direction);

int main()
{
    int i, T;
        
    scanf("%d", &T);
    for (i = 0; i < N-1; ++i)
        goal[i] = i + 1;
    goal[N-1] = 0;
    for (i = 1; i <= T; ++i)
    {
        read(start);
        memcpy(cur, start, N);
        solve();
    }
    
    return 0;
}

void solve()
{
    int i, depth;

    if (inv_judge(start)) puts("This puzzle is not solvable.");
    else
    {
        memset(path, -1, sizeof(path));
        depth = IDAstar();
        for (i = 0; path[i]!=-1; ++i)
        {
            putchar(md[path[i]]);
        }
        putchar('\n');
    }
}

void read(char *s)
{
    int i, t;

    for (i = 0; i < N; ++i)
    {
        scanf("%d", &t);
        s[i] = t;
    }
}

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)
    {
        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 inv_judge(char *s)
{
    char ch, ret;
    int i, j;

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

    return ret;
}

//