poj 1077 Eight(双向bfs)

题目链接：http://poj.org/problem?id=1077

思路分析：题目要求在找出最短的移动路径，使得从给定的状态到达最终状态。

<1>搜索算法选择：由于需要找出最短的移动路径，所以选择bfs搜索

<2>判重方法：

将空格视为数字9，则可以将状态的集合视为1-9的排列组合的集合，根据康托展开，将每一个状态映射到一个正整数中；

在由哈希表进行判重。

<3>状态压缩：在搜索时使用将每个状态转换为一个由1-9组成的9位数字即可进行状态压缩与解压。

<4>双向广度优先搜索的技巧：

1)优点：对于给定了初始状态与目标状态的问题，可以使用双向搜索进行搜索，更能节省空间与时间。

2)双向广度优先搜索的思想：双向广度优先搜索同时开始两种搜索；一个广度优先搜索从给定的状态向目标状态搜索，另外一个广度优先搜索从目标状态

向给定的状态搜索，则会生成两个状态树；搜索时记录每个状态树中的父节点与子节点的关系；当从每个状态树中的一个根结点开始扩展节点时，若扩展

的结点在该状态树中已经出现，则不扩展该节点，若扩展的结点在另一棵状态树中已经存在，则就找到了一条路径连接了初始状态与目标状态(是否最短？)，

因为在一个状态树中初始状态与该状态之间与存在一条路径，而在另一棵状态树中，该状态与目标状态之间存在一条路径，所以以该扩展的结点为连接点，

连接了两棵状态树中的初始状态与目标状态；

代码如下：

#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;

const int MAX_N =  + ; // 10! + 10
int set[MAX_N];                // 状态集合，用来判重，并记录状态的被搜索情况(0:未被搜索 1:正向搜索 2:反向搜索)
int map[];                    // 记录图的状态
char path[MAX_N];              // 在打印路径是记录路径
const int FACT[] = {, , , , , , , , };
const int MOVE[][] = {{, -}, {, }, {-, }, {, }};

struct Node
{
    int state_num;
    int pre, next;            // 状态树记录子节点与父节点
    char pre_dir, next_dir;   // 记录父节点扩展到子节点的移动方向
}state_queue[MAX_N];

int Canto()
{
    int state_num = ;
    for (int i = ; i < ; ++i)
    {
        int temp = map[i] - ;

        for (int j = ; j < i; ++j)
            temp -= (map[j] < map[i]);
        state_num += temp * FACT[ - i];
    }
    return state_num;
}

void StateNumToMAP(int num)
{
    int i = ;
    while (num)
    {
        map[i--] = num % ;
        num /= ;
    }
}

char MoveDirection(bool forward, int i)
{
    char result = ;

    if (!forward)
    {
        if ( <= i && i <= )
            i =  - i;
        else
            i =  - i;
    }

    switch (i)
    {
    case : result = 'u'; break;
    case : result = 'd'; break;
    case : result = 'l'; break;
    case : result = 'r'; break;
    }
    return result;
}

int MapToStateNum()
{
    int ans = ;

    for (int i = ; i < ; ++i)
        ans = ans *  + map[i];
    return ans;
}

int BFS()
{
    int head, tail, state_canto_val;
    Node start, end;

    head = tail = ;
    start.state_num = MapToStateNum();
    start.pre = -;      // -1，表示无父节点
    start.pre_dir = -;  // 同上
    start.next = ;      // 0表示为根结点
    start.next_dir = ;  // 同上
    state_canto_val = Canto();
    set[state_canto_val] = ;

    if (start.state_num == )
        return -;

    end.state_num = ;
    end.next = -;      // -1表示无父节点
    end.next_dir = -;  // 同上
    end.pre = ;        // 0表示为根节点
    end.pre_dir = ;    // 同上

    state_queue[tail++] = start;
    state_queue[tail++] = end;
    set[] = -;

    while (head < tail)
    {
        int now_x, now_y, next_x, next_y;
        Node now_state;

        now_state = state_queue[head];
        StateNumToMAP(now_state.state_num);
        state_canto_val = Canto();

        for (int i = ; i < ; ++i)
        {
            if (map[i] == )
            {
                now_x = i % , now_y = i / ;
                break;
            }
        }
        for (int i = ; i < ; ++i)
        {
            int temp_swap;
            Node next_state;

            next_x = now_x;
            next_y = now_y;
            next_x += MOVE[i][];
            next_y += MOVE[i][];

            if (next_x <  || next_x >=
                || next_y <  || next_y >= )
                continue;
            temp_swap = map[now_x + now_y * ];
            map[now_x + now_y * ] = map[next_x + next_y * ];
            map[next_x + next_y * ] = temp_swap;

            state_canto_val = Canto();
            if (state_queue[head].pre ==  && set[state_canto_val] == )
            {
                set[state_canto_val] = -tail;
                next_state.state_num = MapToStateNum();
                next_state.pre = ;
                next_state.pre_dir = ;
                next_state.next = head;
                next_state.next_dir = MoveDirection(false, i);
                state_queue[tail++] = next_state;
            }
            else if (state_queue[head].pre ==  && set[state_canto_val] > )
            {
                state_queue[abs(set[state_canto_val])].next = head;
                state_queue[abs(set[state_canto_val])].next_dir = MoveDirection(false, i);
                return abs(set[state_canto_val]);
            }
            else if (state_queue[head].next ==  && set[state_canto_val] == )
            {
                set[state_canto_val] = tail;
                next_state.state_num = MapToStateNum();
                next_state.pre = head;
                next_state.pre_dir = MoveDirection(true, i);
                next_state.next = ;
                next_state.next_dir = ;
                state_queue[tail++] = next_state;
            }
            else if (state_queue[head].next ==  && set[state_canto_val] < )
            {
                state_queue[abs(set[state_canto_val])].pre = head;
                state_queue[abs(set[state_canto_val])].pre_dir = MoveDirection(true, i);
                return abs(set[state_canto_val]);
            }

            temp_swap = map[now_x + now_y * ];
            map[now_x + now_y * ] = map[next_x + next_y * ];
            map[next_x + next_y * ] = temp_swap;
        }
        head++;
    }
    return -;
}

void PrintPath(int id)
{
    int pos = ;
    int temp_id = id;

    while (state_queue[temp_id].pre != -)
    {
        path[pos++] = state_queue[temp_id].pre_dir;
        temp_id = state_queue[temp_id].pre;
    }

    for (int i = pos - ; i >= ; --i)
        printf("%c", path[i]);

    temp_id = id;
    while (state_queue[temp_id].next != -)
    {
        printf("%c", state_queue[temp_id].next_dir);
        temp_id = state_queue[temp_id].next;
    }

    printf("\n");
}

int main()
{
    int ans = ;
    char temp_value;

    for (int i = ; i < ; ++i)
    {
        cin >> temp_value;
        if (temp_value == 'x')
            map[i] = ;
        else
            map[i] = temp_value - '';
    }

    memset(set, , sizeof(set));
    ans = BFS();
    if (ans == -)
        printf("unsolvabel\n");
    else if (ans == -)
        printf("\n");
    else
        PrintPath(ans);

    return ;
}