POJ1077Eight

一. 题意：

八数码问题，输入一个3*3的棋盘。其中包含一个x和1到8，用x跟上下左右交换。求到满足状态12345678x时x要怎么移动。

二. 解题方法：

我是用康托展开和逆展开，把棋盘9！种不同的状态映射到0到9！-1个整数，然后用整数代表不同的状态，（暂且理解为一个整数代表一个状态，这好像就是传说中的hash算法吧）比如说123456789是一个状态，987654321是另外一个状态。然后一个状态一个状态搜索。

定义数组visited[]标记不同状态是否被访问过，我直接把x那个位置替换为9，然后从9开始搜索（BFS），定义一个结构体Path，用来存放路径。里面的direction用来表示前一个状态是从那个方向来到当前状态的，pre用来表示当前状态是从前面的哪个状态过来的。当遇见所代表的整数等于0，即所代表的棋盘为123456789，就退出。搜索完还没遇到等于0的情况就是没有解。（透露一个秘密：测试数据根本没有没解这种情况，因为一开始没仔细看题，直接猜样例然后就AC了哈哈哈哈）

三. 预备知识：

1. 组合数学的知识：

康托展开：对于一个全排列，将每一个排列又小到大排序，他们的排列顺序代表它们。给出它的排列，求出它第几大。举个例子比较好理解：

比如对于3个数123，它们的排列有123，132，213，231，312，321共6种，用0，1，2，3，4，5分别代表它们。给出一个312，让你求出4。怎么求呢。有点高中数学知识就够了比3小的数有2个。第一位可以是1, 2。第二位为2！然后看1，比1小的有0个。然后如果后面有继续加，只看后面的子序列，不要往回找。

康托逆展开：给数字求排列。从最高位开始，取整得出有几个数比它当前位数小，取余然后再取整，直接的逆运算，仔细想想就明白了。

四. 本来想写一篇长长的，可以解释得比较清楚的，毕竟这题想了好久，也学了好多啊感觉，然后好像也说不出什么了。毕竟我只用了单向BFS，就完了。只能说，详细看代码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>

using namespace std;

const int MAXSIZE = 362880;

//The list of factorial:
int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};

//Mark whether this state have been tried:
bool visited[MAXSIZE];

//The direction of moving:
int movei[] = {-1, 1, 0, 0};
int movej[] = {0, 0, -1, 1};
char direction[] = {'u', 'd', 'l', 'r'};

struct Path
{
//how to move to current state(By up, down, left or right):
char direction;

//Remember how to reach current(from one state to another state):
int pre;

} path[MAXSIZE];

//Every state:
struct state
{
    int i, j;
    char grid[3][3];
};

//Whether it can be solve:
bool flag;

void order(char str[][3], int &ans)
{
    int i, j, k = 0, numOfMin;
    char temp[9];

    for(i = 0; i < 3; i++)
        for(j = 0; j < 3; j++){
            temp[k] = str[i][j];
            k++;
    }

    ans = 0;
    for(i = 0; i < 8; i++){
            numOfMin = 0;
        for(j = i + 1; j < 9; j++){
            if(temp[i] > temp[j]){
                numOfMin++;
            }
        }
        ans += fac[8 - i]*numOfMin;
    }

}

void getState(int num, state &ans)
{
    int i, j, k = 0, numOfMin;
    char temp[9];

    for(i = 8; i >= 0; i--){
        numOfMin = num/fac[i];
        temp[8-i] = '1' + numOfMin;
        num = num%fac[i];
    }

    for(i = 0; i < 3; i++)
        for(j = 0; j < 3; j++){
            ans.grid[i][j] = temp[k];
            k++;
            if('9' == ans.grid[i][j]){
                ans.i = i;
                ans.j = j;
            }
        }
}

void bfs(state start)
{
    queue <state> que;
    state now, next;
    int i, j, dir, nextOrder, curOrder;

    que.push(start);
    order(start.grid, curOrder);
    path[curOrder].pre = -1;
    visited[curOrder] = true;
    flag = true;

    while(!que.empty()){
        now = que.front();
        que.pop();
        order(now.grid, curOrder);

        for(dir = 0; dir < 4; dir++){
            i = now.i + movei[dir];
            j = now.j + movej[dir];
            if(i >= 0 && i < 3 && j >= 0 && j < 3){
                next = now;
                swap(next.grid[i][j], next.grid[next.i][next.j]);

                order(next.grid, nextOrder);
                if(!visited[nextOrder]){
                    visited[nextOrder] = true;
                    path[nextOrder].direction = direction[dir];
                    next.i = i, next.j = j;
                    path[nextOrder].pre = curOrder;
                    if(0 == nextOrder)
                        return;
                    que.push(next);
                }
            }
        }
    }

    flag = false;
}

void printPath()
{
    char way[1024];
    int k = 0, curOrder = 0, preOrder;

    preOrder = path[0].pre;

    for(k = 0; path[curOrder].pre != -1; k++){

        preOrder = path[curOrder].pre;

        way[k] = path[curOrder].direction;

        curOrder = preOrder;
    }

    for(k--; k >= 0; k--){
        cout<<way[k];
    }

    cout<<endl;
}
int main()
{
    //freopen("in.txt", "r", stdin);

    int i, j;

    state start;

    for(i = 0; i < 3; i++)
        for(j = 0; j < 3; j++){

        cin>>start.grid[i][j];

        if('x' == start.grid[i][j]){
            start.i = i;
            start.j = j;
            start.grid[i][j] = '9';
            }
        }

    bfs(start);
    if(flag)
        printPath();
    else
        cout<<"unsolvable\n";
}

G++250ms。

回头来看，康托逆展开写错了，仔细看下代码，根本没用过！- -。