poj 1077 八数码

#include<iostream>
#include<queue>
#include<algorithm>
#include<string>
#include<cstring>
#include<cstdio>
//正向广度搜索
//把“x"当初0
using namespace std;

const int maxn = 1000000;

int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };   //康拖展开判重
//            0! 1! 2! 3!  4!  5!   6!    7!    8!      9!
int vis[maxn];

int get_priority(int s[]){        //康拖展开求该序列的hash值
    int sum = 0;
    for (int i = 0; i<9; i++){
        int cnt = 0;
        for (int j = i + 1; j<9; j++)
            if (s[i]>s[j])
                cnt++;
        sum += (cnt*fac[9 - i - 1]);
    }
    return sum + 1;
}

struct node{
    int s[9];
    int loc;    //“0”的位置,把“x"当0
    int status;     //康拖展开的hash值
    string path;    //路径
}start;

string path;
int aim = 46234;  //123456780对应的康拖展开的hash值
int dir[4][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };//u,d,l,r
char indexs[5] = "udlr";//正向搜索

int BFS(){
    queue<node> q;
    while (!q.empty())
        q.pop();
    node cur, next;
    q.push(start);
    int x, y;
    while (!q.empty()){
        cur = q.front();
        q.pop();
        if (cur.status == aim){
            path = cur.path;
            return 1;
        }
        x = cur.loc / 3;
        y = cur.loc % 3;
        for (int i = 0; i<4; i++){
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if (tx<0 || tx >= 3 || ty<0 || ty >= 3)
                continue;
            next = cur;
            next.loc = tx * 3 + ty;
            next.s[cur.loc] = next.s[next.loc];
            next.s[next.loc] = 0;
            next.status = get_priority(next.s);
            if (!vis[next.status]){
                vis[next.status] = 1;
                next.path = next.path + indexs[i];
                if (next.status == aim){
                    path = next.path;
                    return 1;
                }
                q.push(next);
            }
        }
    }
    return 0;
}

int main(){

    //freopen("input.txt","r",stdin);

    char ch;
    while (cin >> ch){
        if (ch == 'x'){
            start.s[0] = 0;
            start.loc = 0;
        }
        else
            start.s[0] = ch - '0';
        for (int i = 1; i<9; i++){
            cin >> ch;
            if (ch == 'x'){
                start.s[i] = 0;
                start.loc = i;
            }
            else
                start.s[i] = ch - '0';
        }
        start.status = get_priority(start.s);
        memset(vis, 0, sizeof(vis));
        if (BFS())
            cout << path << endl;
        else
            printf("unsolvable
");
    }
    return 0;
}

void GetNode(int num, int *str) {
    int n = 9;
    int a[9];
    for (int i = 2; i <= n; ++i)
    {
        a[i - 1] = num%i;
        num = num / i;
        str[i - 1] = 0;
    }
    str[0] = 0;
    int rn, i;
    for (int k = n; k >= 2; k--)
    {
        rn = 0;
        for (i = n - 1; i >= 0; --i)
        {
            if (str[i] != 0)
                continue;
            if (rn == a[k - 1])
                break;
            ++rn;
        }
        str[i] = k;
    }
    for (i = 0; i<n; ++i)
        if (str[i] == 0)
        {
            str[i] = 1;
            break;
        }
}

//没看懂神牛路径怎么打印的。。QAQ
# 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;
    
    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('
');
                    return ;
                }
            }
        }
    }
}

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

    for (i = 0; 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;
}