HDU ACM Eight

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1043

解题背景：

看到八数码问题，没有任何的想法，偶然在翻看以前做的题的时候发现解决过类似的一道题，不过那题是求最长的移动步骤，给你的时间有10s之多，用set和queue过了它，这题我套用当时的模板，具体解题点击这里，发现TLE了一辈子。后来直接敲了一遍lrj白书上关于八数码的代码，还是TLE，一天就这样过去了，决定看别人的思路，很快就找到Kuangbin神的代码，代码思路基本相似，只是哈希函数的差别，TLE的原因没其他，卡就卡你的哈希，搜索了多份代码，反复地提到了康托展开，百度之后决定搞懂其。

百度之后发现其只是给你介绍什么是康托展开，然后告诉你康托展开可以用代码实现，然后他就将其用代码展示予你看。||- _ -

康托展开可以看做是特殊的哈希函数，而且是不会产生冲突，固定位数的数在排列组合中得到的数按大小比较的话都有一个特定的位置，康托展开就是计算这个数在当中的排列位置，百度中你会看见：（只是想说清楚这段文字和实现代码的关系）

其举的第二个例子中，即判断1324在排列数中是第几大的数，有一个式子的模型是：X *  Y！，X表示当前数到的位数其后面的数有几个比其小，Y跟此时数到的位数有关，其值是这个排列数的总的位数减去当前数到的位数，即剩下来有几位，Y！的意义是剩下的位数进行排列组合，而X表示有几个数能替代当前数到的位数当前的数，比如说刚数到第一个数时，这里表示能替代1的数有几个（比1小的数），因为你的目的是看这个排列数是第几大的数。对于1324中的1来说为0个；这时只是处理了第一个位置的位数，接下来从左往后还有需要数到的位数，Y也依次减一。最终累加的数才能得出在排列数是第几大的数。实现的代码将这些阶乘都先计算出来。

用此为哈希函数个人感觉有点像位运算通过二进制得到独一无二的数，学习ing。

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#define MAXN 1000003
#define SIZE 9
using namespace std;

typedef int State[SIZE];
int dir[][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
string dirFlag[] = {"l", "r", "u", "d"};
State st[MAXN], goal = {1,2,3,4,5,6,7,8,0};
string dist[MAXN];
int head[MAXN], next[MAXN];

int hash(State& s)
{
    int v = 0;
    for(int i=0; i<SIZE; ++i) v = v*10 + s[i];
    return v%MAXN;
}

int try_to_insert(int s)
{
    int h = hash(st[s]);
    int u = head[h];
    while(u)
    {
        if(memcmp(st[u], st[s], sizeof(st[s])) == 0) return 0;
        u = next[u];
    }
    next[s] = head[h];
    head[h] = s;
    return 1;
}

int Traverse()
{
    memset(head, 0, sizeof(head));
    int front = 1, rear = 2;
    dist[front] = "";
    while(front < rear)
    {
        State& s = st[front];
        if(memcmp(goal, s, sizeof(s)) == 0) return front;
        int z;
        for(z=0; z<SIZE; ++z) if(!s[z]) break;
        int x = z/3, y = z%3;
        for(int d=0; d<4; ++d)
        {
            int newx = x + dir[d][0];
            int newy = y + dir[d][1];
            int newz = newx * 3 + newy;
            if(newx >= 0 && newx < 3 && newy >= 0 && newy < 3)
            {
                State& t = st[rear];
                memcpy(&t, &s, sizeof(s));
                t[newz] = s[z];
                t[z] = s[newz];
                dist[rear].assign(dist[front]);
                dist[rear].append(dirFlag[d]);
                if(try_to_insert(rear)) rear++;
            }
        }
        front++;
    }
    return 0;
}

int main()
 {
      freopen("F:\test\input.txt", "r", stdin);
     char ch;
     while(cin>>ch)
     {
         if(ch == 'x') st[1][0] = 0;
         else st[1][0] = ch - '0';
         for(int i=1; i<SIZE; ++i)
         {
              cin>>ch;
             if(ch == 'x') ch = '0';
             st[1][i] = ch - '0';
        }
        int ans = Traverse();
        if(ans > 0) cout<<dist[ans]<<endl;
        else cout<<"unsolvable"<<endl;
     }
     return 0;
 }

 WA的原因：

如果按照普通的想法来做，一般就像我刚看到题所想到，每一个case都去遍历一遍，每一次都去判段能不能走通这条路，因为是从不定的情况到确定的情况，如果是不可能走通的情况，那么每个case消耗的时间都是最大的，所以TLE是不可避免了。相反，从反过来的情况去判断，一次就能记录下来所有不能达到的情况和记录可以到达情况的步骤。傻傻的就这样想不通，这样我想起了很久之前做的一道题，每个Case都去筛素数.....隔了那么长的时间，思维却丝毫没有改变，嗒嗒

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<queue>
#define MAXN 362888
#define SIZE 9
using namespace std;

typedef int State[SIZE];
int dir[][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
char dirFlag[] = "rldu";

typedef struct Status{
    State value;
}Status;

queue<Status>queuing;

string st[MAXN];
bool visit[MAXN];

int factory[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
const int start = 46233;
int aim = 0;
int input[SIZE];

int try_to_insert(int s[])
{
    int sum = 0;
    for(int i=0; i<SIZE; ++i)
    {
        int cnt = 0;
        for(int j=i+1; j<SIZE; ++j)
            if(s[i]>s[j]) ++cnt;
        sum += cnt*factory[SIZE-i-1];
    }
    return sum;
}

void Traverse()
{
    memset(visit, false, sizeof(visit));
    Status init;
    for(int i=0; i<SIZE-1; ++i) init.value[i] = i+1;
    init.value[SIZE-1] = 0;
    visit[start] = true;
    st[start] = "";
    queuing.push(init);
    while(!queuing.empty())
    {
        Status ss = queuing.front();
        State& s = ss.value;
        queuing.pop();
        int z;
        for(z=0; z<SIZE; ++z) if(!s[z]) break;
        int x = z/3, y = z%3;
        for(int d=0; d<4; ++d)
        {
            int newx = x + dir[d][0];
            int newy = y + dir[d][1];
            int newz = newx * 3 + newy;
            if(newx >= 0 && newx < 3 && newy >= 0 && newy < 3)
            {
                Status tt;
                State& t = tt.value;
                memcpy(t, s, sizeof(s));
                t[newz] = s[z];
                t[z] = s[newz];
                int elem = try_to_insert(s);
                int adr = try_to_insert(t);
                if(!visit[adr])
                {
                    visit[adr] = true;
                    st[adr] = dirFlag[d] + st[elem];
                    queuing.push(tt);
                }
            }
        }
    }
    return;;
}

int main()
 {
 //     freopen("F:\test\input.txt", "r", stdin);
     char ch;
     Traverse();
     while(cin>>ch)
     {
         if(ch == 'x') input[0] = 0;
         else input[0] = ch - '0';
         for(int i=1; i<SIZE; ++i)
         {
              cin>>ch;
             if(ch == 'x') ch = '0';
             input[i] = ch - '0';
        }
        aim = try_to_insert(input);
        if(visit[aim]) cout<<st[aim]<<endl;
        else cout<<"unsolvable"<<endl;
     }
     return 0;
 }