bfs,hash,康托展开（UESTC 485，Game）

一开始时间复杂度算错了。。。当时想一共9！个状态，1000组数据，那么总运算量为3.62880e8，只要数据稍微水一点，那不就过了嘛~~

然而我又搞错了，不但没有考虑编码解码的时间复杂度，更没有考虑状态转移的时间复杂度。

当时觉得编码解码，状态转移都是常数嘛，直接无视不就好啦。

而且前面几题暴力做，结果时间才一点点，所以以为这题也一样。（好吧其实还是自己一直都没算对时间复杂度）

事实上状态转移是一个O（10），编码解码主要是为了记录，记录有多种方法，不一定要编码解码，但是哪怕最优方法也都要O（10）。

两个常数乘起来就是O（100），铁定要超了。以后不能轻视那些常数的小循环啊。。。

正解就不在这里说了，看别人博客吧。

这里只讲时间复杂度的优化。

状态转移是没法优化了，但是记录可以优化。

主要就是三种方法嘛，一是map，二是编码解码，三是hash。

我们从最差到最好依次讲起。

首先是最差的map，方便确实是方便，但是不但常数大，而且还带logn，插入大概相当于O（100）。

然后是编码解码，用康托展开编码解码可以得到一个完美哈希函数。

关于康托展开：http://blog.csdn.net/dacc123/article/details/50952079

但是编码和解码需要两重循环，插入大概相当于O（50）。

我觉得除非要用到双射的性质，这个方法不算太好。

最后是hash，O（1）插入。

所以还是hash最好。

我的方法是把状态保存成一个int类型，所以得到子状态至少也要O（10）。

如果正常保存状态，复制也要O（10）。

所以前面才说最优也要O（10），哪怕用hash。

代码

#include<bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;


//Hash
const int Hashsize = 1000007;
const int maxstate = 362880;
struct Node
{
    int s,d,next;
}node[maxstate];
int head[Hashsize],tot;
void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}
inline int Hash(int s){return s%Hashsize;}
bool try_to_insert(int s,int d)
{
    int h = Hash(s);
    for(int i=head[h];~i;i=node[i].next) if(node[i].s==s) return false;
    node[tot].s=s;
    node[tot].d=d;
    node[tot].next=head[h];
    head[h]=tot++;
    return true;
}
int getd(int s)
{
    int h = Hash(s);
    for(int i=head[h];~i;i=node[i].next) if(node[i].s==s) return node[i].d;
    return inf;
}


int Read()
{
    int ret=0;
    char str[2];
    for(int i=0;i<9;i++)
    {
        scanf("%s",str);
        ret*=10;
        if(isdigit(str[0])) ret+=str[0]-'0';
    }
    return ret;
}

int bit[9];

void res(int s)
{
    for(int i=8;i>=0;i--)
    {
        bit[i]=s%10;
        s/=10;
    }
}

int com()
{
    int ret=0;
    for(int i=0;i<9;i++)
    {
        ret*=10;
        ret+=bit[i];
    }
    return ret;
}

int next(int u,int x)
{
    res(u);
    if(x==1)
    {
        swap(bit[0],bit[6]);
        swap(bit[0],bit[3]);
    }
    else if(x==2)
    {
        swap(bit[1],bit[7]);
        swap(bit[1],bit[4]);
    }
    else if(x==3)
    {
        swap(bit[2],bit[8]);
        swap(bit[2],bit[5]);
    }
    else if(x==4)
    {
        swap(bit[6],bit[0]);
        swap(bit[6],bit[3]);
    }
    else if(x==5)
    {
        swap(bit[7],bit[1]);
        swap(bit[7],bit[4]);
    }
    else if(x==6)
    {
        swap(bit[8],bit[2]);
        swap(bit[8],bit[5]);
    }
    else if(x==7)
    {
        swap(bit[0],bit[2]);
        swap(bit[0],bit[1]);
    }
    else if(x==8)
    {
        swap(bit[3],bit[5]);
        swap(bit[3],bit[4]);
    }
    else if(x==9)
    {
        swap(bit[6],bit[8]);
        swap(bit[6],bit[7]);
    }
    else if(x==10)
    {
        swap(bit[2],bit[0]);
        swap(bit[2],bit[1]);
    }
    else if(x==11)
    {
        swap(bit[5],bit[3]);
        swap(bit[5],bit[4]);
    }
    else
    {
        swap(bit[8],bit[6]);
        swap(bit[8],bit[7]);
    }
    return com();
}

void pre()
{
    init();
    queue<int>q;
    q.push(123456789);
    try_to_insert(123456789,0);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=1;i<=12;i++)
        {
            int v = next(u,i);
            if(try_to_insert(v,getd(u)+1)) q.push(v);
        }
    }
}

int MAP[10];
int ans;
int vis[10];

void dfs(int cur,int num)
{
    if(cur==9)
    {
        ans=min(ans,getd(num));
        return;
    }
    else if(bit[cur]) dfs(cur+1,num*10+MAP[bit[cur]]);
    else for(int i=1;i<=9;i++) if(!vis[i])
    {
        vis[i]=1;
        dfs(cur+1,num*10+MAP[i]);
        vis[i]=0;
    }
}

void solve()
{
    int s,t;
    s=Read();
    t=Read();
    res(s);
    for(int i=0;i<9;i++) MAP[bit[i]]=i+1;
    res(t);
    memset(vis,0,sizeof(vis));
    for(int i=0;i<9;i++) if(bit[i]) vis[bit[i]]=1;
    ans = inf;
    dfs(0,0);
    if(ans==inf) puts("No Solution!");
    else printf("%d\n",ans);
}

int main()
{
    pre();
    int T;
    scanf("%d",&T);
    for(int t=1;t<=T;t++)
    {
        printf("Case #%d: ",t);
        solve();
    }
    return 0;
}