sicily 2011. Nine Digits（广搜，康托展开）

2011. Nine Digits

Constraints

Time Limit: 2 secs, Memory Limit: 256 MB

Description

 Nine tiles, each with a number from 1 to 9 on it, are packed into a 3 by 3 frame. Your task is to arrange the tiles so that they are ordered as:

1 2 3

4 5 6

7 8 9

 

       At each step, you can do the following operation to the tiles: Choose 2 by 2 tiles, rotate the tiles in clockwise order. For example:

       1 2 3             4 1 3                           1 2 3             1 2 3

       4 5 6      =>   5 2 6             or           4 5 6      =>   4 8 5

       7 8 9             7 8 9                           7 8 9             7 9 6

 

       Write a program to find the minimum number of steps.

Input

 Input contains multiple test cases.

       Each test case is a description of a configuration of the nine tiles. The description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and from left to right within a row, where the tiles are represented by numbers 1 to 9. For example:

       9 8 7

       6 5 4

       3 2 1

is described by this list:

       9 8 7 6 5 4 3 2 1

Output

 Output the minimum number of steps on a single line for each test case.

Sample Input

1 2 3 4 5 6 7 8 9
4 1 3 5 2 6 7 8 9

Sample Output

0
3

Problem Source

每周一赛：2010中山大学新手赛

这道题应该是考查广搜+康托压缩（康托展开），广搜用于找最短路，康托压缩是一个特殊的哈希函数，这个哈希函数好就好在它仅仅是一个大小为36W的int数组，能够省下不小内存。其实康托压缩就是把一个排列变成数字，这个数字是全排列中的第几个元素，比如132是123的第二个排列，就输出2。通过这个数字还能逆推回原来的序列。详情见百度百科：康托展开    有了这两个关键方法，设计算法的时候不要按部就班地从当前状态找到123456789这种顺序思路想，因为这样的时间复杂度和查询的次数是成线性关系增加的，会超时。应该从123456789这个状态出发，去找到其他所有状态，这个状态数为9！（9的全排列，包含了这个游戏所有的情况），而且搜索的时候数字变成了逆时针旋转（反过来）。这样只需要搜索一次。最后就是打表过程了。

#include <bits/stdc++.h>
using namespace std;

int fact[10] = {0,1,2,6,24,120,720,5040,40320,362880};//阶乘表
int src[10];
int dst[10] = {1,2,3,4,5,6,7,8,9};
int vis[400000];
int ans[400000];
struct pack{
    int num,k;
    pack(){}
    pack(int num,int k):num(num),k(k){}
};

int cantor(int num){
    int tmp[10];
    int code=0;
    for(int i=0;i<9;i++){
        tmp[8-i]=num%10;
        num/=10;
    }   
        for(int i = 0;i <= 8;++i)//*****康托展开公式：当前位数的逆序数*该位数的阶乘****(本题重点)  
    {  
        int cnt = 0;  
        for(int j = i + 1;j <= 8;j++)  
            if(tmp[i] > tmp[j])    ++cnt;  
        code += fact[8-i] * cnt;  
    } 
    return code;
}

void op_1(int a[],int &num){
    int tmp[10];
    tmp[0]=a[1];
    tmp[1]=a[4];
    tmp[2]=a[2];
    tmp[3]=a[0];
    tmp[4]=a[3];
    tmp[5]=a[5];
    tmp[6]=a[6];
    tmp[7]=a[7];
    tmp[8]=a[8];
    int hash=0;
    for(int i=8;i>=0;i--){
        hash+=tmp[i]*pow(10,8-i);
    }
    num = hash;
}
void op_2(int a[],int &num){
    int tmp[10];
    tmp[0]=a[0];
    tmp[1]=a[2];
    tmp[2]=a[5];
    tmp[3]=a[3];
    tmp[4]=a[1];
    tmp[5]=a[4];
    tmp[6]=a[6];
    tmp[7]=a[7];
    tmp[8]=a[8];
    int hash=0;
    for(int i=8;i>=0;i--){
        hash+=tmp[i]*pow(10,8-i);
    }
    num = hash;
}
void op_3(int a[],int &num){
    int tmp[10];
    tmp[0]=a[0];
    tmp[1]=a[1];
    tmp[2]=a[2];
    tmp[3]=a[4];
    tmp[4]=a[7];
    tmp[5]=a[5];
    tmp[6]=a[3];
    tmp[7]=a[6];
    tmp[8]=a[8];
    int hash=0;
    for(int i=8;i>=0;i--){
        hash+=tmp[i]*pow(10,8-i);
    }
    num = hash;
}
void op_4(int a[],int &num){
    int tmp[10];
    tmp[0]=a[0];
    tmp[1]=a[1];
    tmp[2]=a[2];
    tmp[3]=a[3];
    tmp[4]=a[5];
    tmp[5]=a[8];
    tmp[6]=a[6];
    tmp[7]=a[4];
    tmp[8]=a[7];
    int hash=0;
    for(int i=8;i>=0;i--){
        hash+=tmp[i]*pow(10,8-i);
    }
    num = hash;
}


void bfs(){
    memset(vis,0,sizeof(vis));
    queue<pack> box;
    int hash=0;
    for(int i=8;i>=0;i--){
        hash+=dst[i]*pow(10,8-i);
    }
    box.push(pack(hash,0));
    while(!box.empty()){
        int tmp[10];
        int sum=box.front().num;
        int k=box.front().k;
        //cout<<sum<<endl;
        box.pop();
        //判重 
        int hash=cantor(sum);
        if(vis[hash])
        continue;
        vis[hash]=1;
        ans[hash]=k;
        
        int cur[10];
        int sum_tmp;
        for(int i=0;i<9;i++){
            cur[8-i]=sum%10;
            sum/=10;
        }
        op_1(cur,sum_tmp);
        box.push(pack(sum_tmp,k+1));
        op_2(cur,sum_tmp);
        box.push(pack(sum_tmp,k+1));
        op_3(cur,sum_tmp);
        box.push(pack(sum_tmp,k+1));
        op_4(cur,sum_tmp);
        box.push(pack(sum_tmp,k+1));
    }
}
int main(){
    bfs();
    while(~scanf("%d",&src[0])){
        for(int i=1;i<9;i++)
        scanf("%d",&src[i]);
        int hash=0;
        for(int i=8;i>=0;i--){
            hash+=src[i]*pow(10,8-i);
        }
        printf("%d\n",ans[cantor(hash)]);
    }
}