POJ1077 Eight —— 反向BFS

主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html

代码一：以数组充当队列，利用结构体中的pre追溯上一个状态在数组（队列）中的下标：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
#define ms(a,b) memset((a),(b),sizeof((a)))
using namespace std;
typedef long long LL;
const int INF = 2e9;
const LL LNF = 9e18;
const int MOD = 1e9+7;
const int MAXN = 1e6+10;

struct node
{
    int status;
    int s[9];
    int loc;
    char op;
    int pre;    //pre为上一个操作在队列中的下标，用于输出路径
};

int vis[MAXN], fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int dir[4][2] = { 0,1,0,-1,  1,0, -1,0  };
char op[4] = {'l', 'r', 'u', 'd'  };    //由于反向操作，则方向应该反过来
int id[MAXN];

int cantor(int s[])     //获得哈希函数值
{
    int sum = 0;
    for(int i = 0; i<9; i++)
    {
        int num = 0;
        for(int j = i+1; j<9; j++)
            if(s[j]<s[i])
                num++;
        sum += num*fac[8-i];
    }
    return sum+1;
}

node que[MAXN];
int front, rear;
void bfs()
{
    ms(vis, 0);
    front = rear = 0;

    node now, tmp;
    for(int i = 0; i<9; i++)    //初始状态为123456789
        now.s[i] = i+1;
    now.loc = 8;
    now.status = cantor(now.s);
    vis[now.status] = 1;
    id[now.status] = rear;   //初始状态在队列中的下标
    que[rear++] = now;

    while(front!=rear)
    {
        now = que[front++];
        int x = now.loc/3;
        int y = now.loc%3;
        for(int i = 0; i<4; i++)
        {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
            {
                tmp = now;
                tmp.s[x*3+y] = tmp.s[xx*3+yy];
                tmp.s[xx*3+yy] = 9;
                tmp.status = cantor(tmp.s);
                if(!vis[tmp.status])
                {
                    vis[tmp.status] = 1;
                    tmp.loc = xx*3+yy;
                    tmp.op = op[i];
                    tmp.pre = front-1;
                    id[tmp.status] = rear;
                    que[rear++] = tmp;
                }
            }
        }
    }
}

void Print(int i)
{
    if(i==0) return;    //队列下标为0的时候为初始状态， 应返回
    putchar(que[i].op); //输出操作
    Print(que[i].pre);  //访问BFS的上一步，但因为是反向BFS，所以对于答案来说是下一步，应放在putchar后面
}

int main()
{
    bfs();//反向bfs，预处理所有情况。然后在访问的时候直接输出路径
    char str[50];
    while(gets(str))
    {
        node aim;
        int cnt = 0;
        for(int i = 0; str[i]; i++)
        {
            if(str[i]==' ') continue;
            if(str[i]=='x') aim.s[cnt] = 9, aim.loc = cnt++;
            else  aim.s[cnt++] = str[i]-'0';
        }
        aim.status = cantor(aim.s);
        if(!vis[aim.status])
            puts("unsolvable");
        else
            Print(id[aim.status]), putchar('
');
    }
}

代码二（推荐）：把pre和path放在结构体外，利用当前状态status追溯上一个状态status：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
#define ms(a,b) memset((a),(b),sizeof((a)))
using namespace std;
typedef long long LL;
const int INF = 2e9;
const LL LNF = 9e18;
const int MOD = 1e9+7;
const int MAXN = 1e6+10;

struct node
{
    int status;
    int s[9];
    int loc;
};

int vis[MAXN], fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int dir[4][2] = { 0,1,0,-1,  1,0, -1,0  };
char op[4] = {'l', 'r', 'u', 'd'  };    //由于反向操作，则方向应该反过来
char path[MAXN];
int pre[MAXN];

int cantor(int s[])     //获得哈希函数值
{
    int sum = 0;
    for(int i = 0; i<9; i++)
    {
        int num = 0;
        for(int j = i+1; j<9; j++)
            if(s[j]<s[i])
                num++;
        sum += num*fac[8-i];
    }
    return sum+1;
}

queue<node>que;
void bfs()
{
    ms(vis, 0);
    while(!que.empty()) que.pop();

    node now, tmp;
    for(int i = 0; i<9; i++)    //初始状态为123456789
        now.s[i] = i+1;
    now.loc = 8;
    now.status = cantor(now.s);
    vis[now.status] = 1;
    pre[now.status] = -1;
    que.push(now);

    while(!que.empty())
    {
        now = que.front();
        que.pop();
        int x = now.loc/3;
        int y = now.loc%3;
        for(int i = 0; i<4; i++)
        {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
            {
                tmp = now;
                tmp.s[x*3+y] = tmp.s[xx*3+yy];
                tmp.s[xx*3+yy] = 9;
                tmp.status = cantor(tmp.s);
                if(!vis[tmp.status])
                {
                    vis[tmp.status] = 1;
                    tmp.loc = xx*3+yy;
                    path[tmp.status] = op[i];
                    pre[tmp.status] = now.status;
                    que.push(tmp);
                }
            }
        }
    }
}

void Print(int status)
{
    if(pre[status]==-1) return;
    putchar(path[status]);
    Print(pre[status]);
}

int main()
{
    bfs();//反向bfs，预处理所有情况。然后在访问的时候直接输出路径
    char str[50];
    while(gets(str))
    {
        node aim;
        int cnt = 0;
        for(int i = 0; str[i]; i++)
        {
            if(str[i]==' ') continue;
            if(str[i]=='x') aim.s[cnt] = 9, aim.loc = cnt++;
            else  aim.s[cnt++] = str[i]-'0';
        }
        aim.status = cantor(aim.s);
        if(!vis[aim.status])
            puts("unsolvable");
        else
            Print(aim.status), putchar('
');
    }
}