eight

学习了多位大牛的方法，看看到底能把时耗降到多少？

A*

// zojfulltest: 30000ms
# include <stdio.h>
# include <ctype.h>
# include <stdlib.h>
# include <string.h>

# define DATA(x,i) (((x)>>((i)*3))&0x7)
# define ZERO(x) ((x)>>27)
# define F(x) ((x)&0xFF)
# define D(x) (((x)>>8)&0xF)
# define P(x) ((x)>>12)
# define MAKE(f,d,p) ((f)|((d)<<8)|((p)<<12))
# define LESS(x,y) (((x)-(y))>>31)
# define SWP(i,j,t) (((t)<<(3*(i)))-((t)<<(3*(j)))+((j)<<27)-((i)<<27))

const unsigned int maxd = 35;
//dest: 0100 0000 0001 1111 0101 1000 1101 0001
const unsigned int dest = 0x401F58D1;
const unsigned int hashmod = 10007;
const unsigned int maxnode = 0x1<<15;
const unsigned int maxsize = 0x1<<13;
const int mv[][4] = {{-1,-1,1, 3},{-1,0,2, 4},{-1,1,-1, 5},
    { 0,-1,4, 6},{ 1,3,5, 7},{ 2,4,-1, 8},
    { 3,-1,7,-1},{ 4,6,8,-1},{ 5,7,-1,-1}};
const char mvs[] = "ulrd";

struct state {
    unsigned int u, v;
};
state a[maxnode], child;
unsigned int src, depth, totnode, h[9][9], t[9];
unsigned int head[hashmod], next[maxnode];
unsigned int hp[maxsize], hps;
unsigned int stk[maxsize], top;

void init(void)
{
    memset(h, 0, sizeof(h));
    for (int j, i = 1; i != 9; ++i) {
        for (j = 0; j != 9; ++j) {
            h[i][j] = abs(j/3-(i-1)/3)+abs(j%3-(i-1)%3);
        }
    }
    for (int i = 0; i != 9; ++i) {
        h[0][i] = h[8][i];
    }
}
bool read_src(void)
{
    src = 0;
    for (int ch, i = 0; i != 9; ) {
        ch = getchar();
        if (isdigit(ch)) t[i++] = ch-'0';
        else if (ch == 'x') {
            t[i] = 0;
            src |= ((i++)<<27);
        } else if (ch == EOF) return false;
    }
    for (int i = 0; i != 9; ++i)  src |= ((t[i]&0x7)<<(3*i));
    return true;
}
bool no_answer(void)
{
    int inv = -ZERO(src), i, j;
    for (i = 0; i != 8; ++i) {
        for (j = i+1; j != 9; ++j) {
            inv += LESS(t[j],t[i]);
        }
    }
    return ((inv)&0x1);
}
void print_sol(int ID)
{
    if (ID == 1) return ;
    print_sol(P(a[ID].v));
    putchar( mvs[D(a[ID].v)] );
}
void addnode(void)
{
    int k = child.u % hashmod;
    for (int w = head[k]; w ; w = next[w]) {
        if (a[w].u == child.u) {
            if ( LESS(F(child.v), F(a[w].v)) ) {
                a[w].v = child.v;
                stk[top++] = w;
            }
            return ;
        }
    }
    a[++totnode] = child;
    next[totnode] = head[k];  head[k] = totnode;
    if ( F(child.v) == depth ) stk[top++] = totnode;
    else hp[hps++] = totnode;
}

void solve(void)
{
    if (no_answer()) { puts("unsolvable"); return; }
    if (src == dest) { puts(""); return ; }
    depth = -h[0][ZERO(src)];
    totnode = 0;
    hps = top = 0;
    memset(head, 0, sizeof(head));
    for (int i = 0; i != 9; ++i) {
        depth += h[ DATA(src,i) ][i];
    }
    child.u = src;
    child.v = MAKE(depth, 4, 1);
    addnode();
    unsigned int ID;
    for ( ; LESS(depth, maxd); depth += 2) {
        while (hps) {
            ID = hp[--hps];
            if ( F(a[ID].v) == depth ) {
                stk[top++] = ID;
            }
        }
        while (top) {
            ID = stk[--top];
            state & cur = a[ID];
            int i = ZERO(cur.u), j;
            for (int r = 0; r != 4; ++r) {
                if (-1!=(j=mv[i][r]) && (D(cur.v)+r)!=3) {
                    int t = DATA(cur.u, j);
                    child.u = cur.u+SWP(i,j,t);
                    int f = F(cur.v)+1+h[t][i]-h[t][j];
                    child.v = MAKE(f,r,ID);
                    if (child.u == dest) {
                        a[++totnode] = child;
                        print_sol(totnode); puts("");
                        return ;
                    }
                    addnode();
                }
            }
        }
    }
}

int main()
{
    init();
    while (read_src()) solve();

    return 0;
}

BFS + 记忆化

// zojfulltest: 1012ms
# include <stdio.h>
# include <ctype.h>
# include <string.h>

# define LESS(x,y) (((x)-(y))>>31)
# define DATA(x,i) (((x)>>((i)*3))&0x7)
# define ZERO(x) ((x)>>27)
# define P(x) ((x)>>4)
# define D(x) ((x)&0xF)
# define MAKE(d,p) ((d)|((p)<<4))
# define SWP(i,j,t) (((t)<<(3*(i)))-((t)<<(3*(j)))+((j)<<27)-((i)<<27))

const int totnode = 362881;
const int maxsize = 181445;
const int dest = 0x401F58D1;
const int destID = 40319;
const int fact[] = {1,1,2,6,24,120,720,5040,40320};
const int mv[][4] = {{-1,-1,1, 3},{-1,0,2, 4},{-1,1,-1, 5},
    { 0,-1,4, 6},{ 1,3,5, 7},{ 2,4,-1, 8},
    { 3,-1,7,-1},{ 4,6,8,-1},{ 5,7,-1,-1}};
const char mvs[] = "ulrd";

struct state {
    unsigned int s;
    unsigned int c;
} hp[maxsize], child;

unsigned int front, rear, src, table[totnode];

unsigned int cantor(unsigned int s)
{
    unsigned int ret = 0;
    unsigned int t[9], i;
    for (i = 0; i != 9; ++i) t[i] = DATA(s,i);
    for (i = 0; DATA(s,i)||i==ZERO(s); ++i) ;
    t[i] = 8;
    for (i = 1; i != 9; ++i) {
        unsigned int inv = 0;
        for (int j = 0; j != i; ++j) {
            inv += LESS(t[j],t[i]);
        }
        ret += inv*fact[i];
    }
    return ret;
}
void build_tree(void)
{
    front = rear = 0;
    child.s = dest, child.c = destID;
    table[destID] = MAKE(4,destID);
    hp[rear++] = child;
    while (LESS(front, rear)) {
        state & cur = hp[front++];
        int i = ZERO(cur.s), d = table[cur.c], j;
        for (int r = 0; r != 4; ++r) {
            if (~(j=mv[i][r]) && (d+r)!=3) {
                child.s = cur.s+SWP(i,j,DATA(cur.s,j));
                child.c = cantor(child.s);
                if (table[child.c] == 0) {
                    table[child.c] = MAKE(r, cur.c);
                    hp[rear++] = child;
                }
            }
        }
    }
}
bool read_src(void)
{
    src = 0;
    for (int ch, i = 0; i != 9; ) {
        ch = getchar();
        if (isdigit(ch)) src |= (((ch-'0')&0x7)<<(3*i++));
        else if (ch == 'x') src |= ((i++)<<27);
        else if (ch == EOF) return false;
    }
    return true;
}
void print_sol(int ID)
{
    while (ID != destID) {
        putchar(mvs[3-D(table[ID])]);
        ID = P(table[ID]);
    }
}
void solve(void)
{
    unsigned int c = cantor(src);
    if (!table[c]) printf("unsolvable");
    else print_sol(c);
    printf("
");
}
int main()
{
    build_tree();
    while (read_src()) solve();
}

构造

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

# define LESS(x, y) (((x)-(y))>>31)
# define REP(n) for ((i) = 0; src[i] != (n); ++(i))

const char *t0[] = {"rd","d","ld","r","","l","ur","u","ul"};
const char *t1[] = {"","lurd","urdllurd","uldr","","urdlurdllurd","ldruuldr","ldruldruuldr","rdluurdlurdllurd"};
const char *t2[] = {"","urddllur","urdlurddllur","","","rdllur","ldru","dlur","druldlur"};
const char *t3[] = {"","ruld","","","","urdl","dlurdrulurdlldru","drulurdl","rdluurdl"};
const char *t4   =  "ldrrulurdl";
const char *t5[] = {"","","","","","rdllur","ldru","dlur","druldlur"};
const char *t6[] = {"","","","","","rdlu","dlurdrulldrurdlu","","rdlurdlu"};
const char *t7   = "dlur";
const char *t8[] = {"","","","","","rd","","dr","rdlurd"};
const char *mvs  = "ulrd";
const int  mv[][4]  = {{-1,-1,1, 3},{-1,0,2, 4},{-1,1,-1, 5},
    { 0,-1,4, 6},{ 1,3,5, 7},{ 2,4,-1, 8},
    { 3,-1,7,-1},{ 4,6,8,-1},{ 5,7,-1,-1}
};

unsigned int src[9], pos;
char ans[100], top;

int mr(char ch)
{
    switch(ch) {
    case 'u':
        return 0;
    case 'l':
        return 1;
    case 'r':
        return 2;
    case 'd':
        return 3;
    }
}
void mov(const char * str)
{
    int n = strlen(str);
    for (int i = 0; i < n; ++i) {
        int t = mv[pos][mr(str[i])];
        src[pos] = src[t];
        src[pos = t] = 0;
    }
    memcpy(ans+top, str, n);
    top += n;
}
void solve(void)
{
    int i;
    top = 0;
    mov( t0[pos] ); // 0->4
    REP(1);
    mov( t1[i] ); // 1->0
    REP(3);
    mov( t2[i] ); // 3->3
    REP(2);
    mov( t3[i] ); // 2->2
    mov( t4 ); // 2->1, 3->2
    REP(7);
    mov( t5[i] ); // 7->3
    REP(4);
    mov( t6[i] ); // 4->7
    mov( t7 ); // 4->3, 7->7
    REP(5);
    mov( t8[i] ); // 5->4, 0->8
    ans[top] = 0;
    if ( src[7] == 8 ) puts(ans);
}
bool no_answer(void)
{
    int inv = -pos;
    for (int i = 0; i != 8; ++i) {
        for (int j = i+1; j != 9; ++j) {
            inv += LESS(src[j], src[i]);
        }
    }
    return ((inv)&0x1);
}
bool read_src(void)
{
    for (int i = 0; i != 9; ) {
        int ch = getchar();
        if (isdigit(ch)) src[i++] = ch-'0';
        else if (ch == 'x') src[pos = i++] = 0;
        else if (ch == EOF) return false;
    }
    return true;
}
int main()
{
    while ( read_src() ) {
        if ( no_answer() ) puts("unsolvable");
        else solve();
    }
    return 0;
}

fulltest.txt