八数码（IDA*）

IDA*+曼哈顿 相当快！ 通过五组数据总计用时 0.015000 s.

把宏定义中的N和SIZE改一下，就可以处理十五数码问题了，终于修炼到第八层了；

刚开始还是使用结构体定义了状态，写得相当麻烦，后来发现IDA*中不像BFS和A*，只需要考虑一条路，，参考了lym（http://www.cnblogs.com/liyongmou/archive/2010/07/19/1780861.html）的（后面调试的受不了了，对照着此大牛的代码一点点改，最后发现是更新状态时，npos写成了pos……）

# include <stdio.h>

# include <math.h>

# include <string.h>

# include <time.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 move(void);

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);

void print_state(char *s);



int main()

{

         freopen("in.txt", "r", stdin);

         freopen("out.txt", "w", stdout);



    while (read(start))

    {

        read(goal);

        memcpy(cur, start, N);

        solve();

    }

    

    printf("time cost %.6lf s.\n", (double)clock()/CLOCKS_PER_SEC);



    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]]);

        }

        printf(" %d\n", i);

    }

    //move(); //打印移动过程，调试的时候用的，加上这个总共用时31ms

}



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;

}



void move(void)

{

    char ncur[N];

    int i, pos, nx, ny, npos;



    memcpy(ncur, start, N);

    print_state(ncur);

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

    pos = i;

    for (i = 0; path[i] != -1; ++i)

    {

        nx = pos/SIZE + dir[path[i]][0];

        ny = pos%SIZE + dir[path[i]][1];

        npos = nx*SIZE + ny;

        ncur[pos] = ncur[npos]; ncur[npos] = 0;

        pos = npos;

        print_state(ncur);

    }

}



void print_state(char *s)

{

    int i;



    for (i = 0; i < N; ++i)

    {

        putchar(s[i]+'0');

    }

    putchar('\n');

}

//