HDOJ 1043 eight

实际上和POJ 1077一样，但是这里有多组输入，并且有一组输入为12345678x（也就是不需要移动就达到了目标状态），这时还要输出一个空行。

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

# define N 9
# define MAXN (362880 + 10)

typedef struct{ int k; char d; } foot;
typedef struct{ char a[N]; } state;

const char md[4] = {'u', 'l', 'r', 'd'};
const char d[4][2] = {{-1,0}, {0,-1}, {0,1}, {1,0}};
const int fact[9] = {1, 1, 2, 6, 24, 120, 720, 720*7, 720*56};

state Q[MAXN/10];  /* 对求最短路足够用了 */
char vis[MAXN];
foot p[MAXN];

int cantor(state s)
{
    char ch;
    int i, j, cnt, ret;

    ret = 0;
    for (i = 0; i < N-1; ++i)
    {
        cnt = 0;
        ch = s.a[i];
        for (j = i+1; j < N; ++j)
            if (s.a[j] < ch) ++cnt;
        ret += cnt*fact[8-i];
    }

    return ret;
}

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

void print_path(int x, char f)
{
    if (p[x].k == 0) return ;
    if (f) putchar(md[3-p[x].d]);
    print_path(p[x].k, f);
    if (!f) putchar(md[p[x].d]);
}

void bfs(state start, state goal)
{
    char t;
    state cur, nst;
    int front, rear, i;
    int x, y, nx, ny, ct, nt;

    memset(Q, 0, sizeof(Q));
    memset(p, 0, sizeof(p));
    memset(vis, 0, sizeof(vis));

    Q[front = 1] = start;
    Q[rear = 2] = goal;
    vis[cantor(start)] = 1;
    vis[cantor(goal)] = 2;

    while (front <= rear)
    {
        cur = Q[front++];
        ct = cantor(cur);
        for (i = 0; cur.a[i] && i < N; ++i) ;
        x = i / 3;
        y = i % 3;
        for (i = 0; i < 4; ++i)
        {
            nx = x + d[i][0];
            ny = y + d[i][1];
            if (nx>=0 && nx<3 && ny>=0 && ny<3)
            {
                nst = cur;
                nst.a[x*3+y] = cur.a[nx*3+ny];
                nst.a[nx*3+ny] = 0;
                nt = cantor(nst);
                if (!vis[nt])
                {
                    Q[++rear] = nst;
                    p[nt].k = ct;
                    p[nt].d = i;
                    vis[nt] = vis[ct];
                }
                else if (vis[ct] != vis[nt])
                {
                    t = (vis[ct]==1 ? 1:0);
                    print_path(t ? ct:nt, 0);
                    putchar(md[t ? i:3-i]);
                    print_path(t ? nt:ct, 1);
                    putchar('\n');
                    return ;
                }
            }
        }
    }
}

int main()
{
    char i, c[5];
    state start, goal;

    while(~scanf("%s", c))
    {
        start.a[0] = (c[0]=='x' ? 0:c[0]-'0');
        for (i = 1; i < N; ++i)
        {
            scanf("%s", c);
            start.a[i] = (c[0]=='x' ? 0:c[0]-'0');
        }
        goal.a[8] = 0;
        for (i = 0; i < N-1; ++i)
            goal.a[i] = i + 1;

        for (i = 0; start.a[i] == goal.a[i] && i < N; ++i) ;
        if (i == N) puts("");
        else if (bool_inv(start) != bool_inv(goal)) puts("unsolvable");
        else bfs(start, goal);
    }

    return 0;
}

//