zoj 1217

非常经典的题目 八数码问题 不能不AC的题

这道题学了不少东西 试了最土的单向BFS直接TLE 然后上网看代码 改了双向的BFS 6000ms+ 过了

关于这道题的判重也是遇到了不少困难，一开始想把状态当成1个整数，把x当成0，结果还真去写了，突然发现数组根本不能开这么大

于是想了想其实这状态总数也才 9!  = 362880 就想只用这个数量的数组储存状态 把整个序列当做一个整数 我只要知道这个数在所有排列里第几个大就可以了 后来查了下这叫康托展开 转一段介绍

这里我们介绍一种可以将全排列的一种表示为“第几个排列”的方法——康托展开。

首先看几个康托展开的实例（9的全排列）：

1 2 3 4 5 6 7 8 9——展开为 0。

1 2 3 4 5 6 7 9 8——展开为 1。

1 2 3 4 5 6 8 7 9——展开为 2。

由这些最开始的方法我们可以发现一个规律：从第一个数开始，依次判断判断这些数是当前没有出现过的数的第几个（由0开始），记为a1, a2, ... ,a(n - 1)。不难发现如1 2 3 4 5 6 8 7 9，由1至6都是当前没有出现过的第0个数，而8是7,8,9中的第1个（由0开始），9是7,9中的第1个，7是第0个。故a1 = a2 = ... = a6 = 0，a7 = 1，a8 = 1，a9 = 0。

之后排列数（康托展开的值）等于

a1 * (n - 1)! + a2 * (n - 2)! + ... + ak * (n - k)! + ... + an * 0!

再举几个例子：

3 5 7 4 1 2 9 6 8——展开为 98884。

5 6 7 8 1 2 3 4 9——展开为 184800。

至于双向BFS 就是知道初始和目标状态的情况下，就可以正向反向一起广搜，找到一个另一方向已搜到过的节点就得到解了

一般来讲每次选择队列中节点比较少的一边来进行下一次搜索。

双向BFS的代码

#include<iostream> #include<string> using namespace std; const string des = "123456780"; int F[362881]; int fact[9] = {1,1,2,6,24,120,720,5040,40320}; string beg = "123456780"; int xpos; int dxdy[ 10 ][ 4 ] = { {-1,-1, 1, 3}, // 0号位的变化 {-1, 0, 2, 4}, // 1号位的变化 {-1, 1,-1, 5}, // 2号位的变化 { 0,-1, 4, 6}, // 3号位的变化 { 1, 3, 5, 7}, // 4号位的变化 { 2, 4,-1, 8}, // 5号位的变化 { 3,-1, 7,-1}, // 6号位的变化 { 4, 6, 8,-1}, // 7号位的变化 { 5, 7,-1,-1}}; // 8号位的变化 char dir[4] = {'u','l','r','d'}; struct node { string cur; string op; int pos; }qs[362881],qe[362881]; long hashfun(const string& s) { long r = 0; for(int i = 1;i < 9;++i) { int num = 0; if(i < 5) { for(int j = 0;j < i;++j) { if(s[j] > s[i]) ++num; } } else { for(int j = i + 1;j < 9;++j) { if(s[j] > s[i]) ++num; } num = 8 - (s[i]-'0') - num; } r += num * fact[i]; } return r; }; string BFS() { int head1,head2,rear1,rear2; head1 = head2 = 0; rear1 = rear2 = 1; qs[0].cur = beg; qs[0].op = ""; qs[0].pos = xpos; F[hashfun(beg)] = 1; qe[0].cur = des; qe[0].op = ""; qe[0].pos = 8; F[hashfun(des)] = 2; while(rear1 + rear2 < 181441 ) { if(rear1 - head1 < rear2 - head2) { if(head1 < rear1) { node temp = qs[head1]; ++head1; int pos = temp.pos; for(int i = 0;i < 4;++i) { if(dxdy[pos][i] < 0) continue; int cpos = dxdy[pos][i]; string ts = temp.cur; ts[pos] = ts[cpos]; ts[cpos] = '0'; long hv = hashfun(ts); string cop = temp.op + dir[i]; if(F[hv] % 10 == 2) return cop + qe[F[hv]/10].op; else if(F[hv] == 0) { F[hv] = rear1 * 10 + 1; qs[rear1].cur = ts; qs[rear1].op = cop; qs[rear1++].pos = cpos; } } } } else { if(head2 < rear2) { node temp = qe[head2]; ++head2; int pos = temp.pos; for(int i = 0;i < 4;++i) { if(dxdy[pos][i] < 0) continue; int cpos = dxdy[pos][i]; string ts = temp.cur; ts[pos] = ts[cpos]; ts[cpos] = '0'; long hv = hashfun(ts); string cop = dir[3-i] + temp.op; if(F[hv] % 10 == 1) return qs[F[hv]/10].op + cop; else if(F[hv] == 0) { F[hv] = rear2 * 10 + 2; qe[rear2].cur = ts; qe[rear2].op = cop; qe[rear2++].pos = cpos; } } } } } }; int count(const string& s) { int ct = 0; for(int i = 1;i < 9;++i) { if(s[i] == '0') continue; for(int j = 0;j < i;++j) { if(s[j] > s[i]) ++ct; } } return ct; }; int main() { while(cin>>beg[0]) { cin>>beg[1]>>beg[2]>>beg[3]>>beg[4]>>beg[5]>>beg[6]>>beg[7]>>beg[8]; for(xpos = 0;xpos < 9;++xpos) { if(beg[xpos] == 'x') { beg[xpos] = '0'; break; } } memset(F,0,sizeof(F)); if(count(beg)&1) printf("unsolvable/n"); else { string s = BFS(); int len = s.length(); for(int i = 0;i < len;++i) printf("%c",s[i]); printf("/n"); } } return 0; }

 

后来在网上查到了A*算法 是一种启发式搜索算法 因为这道题并不要求最优解，所以还是速度重要 空间上的开销的话 已经算出只有9！个

状态 所以可以用A*算法 启发式算法对我来说还是太复杂了 其实并搞不懂 这道题参考了网上的介绍和代码 写了一个A* 速度确实快的多

下面摘一段一个大牛对8数码问题的研究报告 

启发式搜索是在路径搜索问题中很实用的搜索方式，通过设计一个好的启发式函数来计算状态的优先级，优先考虑优先级高的状态，可以提早搜索到达目标态的时间。A*是一种启发式搜索的，他的启发式函数f ' ()=g' () + h' () 能够应用到八数码问题中来。
        g' () ----- 从起始状态到当前状态的实际代价g*()的估计值，g' () >= g*()
        h' () ----- 从当前状态到目标状态的实际代价h*()的估计值，h' () <= h*()
注意两个限制条件：
        （1）h' () <= h*()  （2）任意状态的f '()值必须大于其父状态的f '()值，即f '()单调递增。

        其中，g' () 是搜索的深度， h' () 则是一个估计函数，用以估计当前态到目标态可能的步数。解八数码问题时一般有两种估计函数。比较简单的是difference ( Status a,  Status b )， 其返回值是a 和b状态各位置上数字不同的次数。另一种比较经典的是曼哈顿距离   manhattan ( Status a, Status b )，其返回的是各个数字从a的位置到b的位置的距离（见例子）。

例如状态 1 3 7 2 4 6 8 5 2 和状态 1 2 3 4 5 6 7 8 9 的difference 是5（不含空格）。而他的manhattan 距离是：
1 (7d一次) + 1 (2u一次) + 2 (4l两次) + 3 (6r两次u一次) + 2 (5u一次l一次) = 9
单个数字的manhattan应该小于5，因为对角的距离才4，若大于4则说明计算有误。

        无论是difference还是manhattan，估计为越小越接近END，所以优先级高。
        在计算difference和manhattan时，推荐都将空格忽略，因为在difference中空格可有可无，对整体搜索影响不大。

        本文后面的实现将使用manhattan 不计空格的方法。其实，每移动一步，不计空格，相当于移动一个数字。如果每次移动都是完美的，即把一个数字归位，那么START态到END态的距离就是manhattan。反过来说，manhattan是START到END态的至少走的步数。
        回到f '()=g' ()+ h' ()，其实广度搜索是h' ()=0的一种启发式搜索的特例，而深度搜索是   f ' ()=0 的一般搜索。h' ()对于优化搜索速度有很重要的作用。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ray58750034/archive/2006/02/15/599897.aspx

我用的估计函数是Manhattan距离

下面是代码 我的代码效率太低 双向广搜和A* 都没有达到理想的效果 只是AC了1217 运行时间比大牛们用一样的算法慢很多

#include<iostream> #include<cmath> #include<string> #include<queue> using namespace std; const string des = "123456780"; string beg = "123456780"; int fact[9] = {1,1,2,6,24,120,720,5040,40320}; int xpos; char dir[4] = {'u','l','r','d'}; int dxdy[ 10 ][ 4 ] = { {-1,-1, 1, 3}, // 0号位的变化 {-1, 0, 2, 4}, // 1号位的变化 {-1, 1,-1, 5}, // 2号位的变化 { 0,-1, 4, 6}, // 3号位的变化 { 1, 3, 5, 7}, // 4号位的变化 { 2, 4,-1, 8}, // 5号位的变化 { 3,-1, 7,-1}, // 6号位的变化 { 4, 6, 8,-1}, // 7号位的变化 { 5, 7,-1,-1}}; // 8号位的变化 int hashfun(const string& s) { long r = 0; for(int i = 1;i < 9;++i) { int num = 0; if(i < 5) { for(int j = 0;j < i;++j) { if(s[j] > s[i]) ++num; } } else { for(int j = i + 1;j < 9;++j) { if(s[j] > s[i]) ++num; } num = 8 - (s[i]-'0') - num; } r += num * fact[i]; } return r; }; int count(const string& s) { int ct = 0; for(int i = 1;i < 9;++i) { if(s[i] == '0') continue; for(int j = 0;j < i;++j) { if(s[j] > s[i]) ++ct; } } return ct; }; int manhattan(const string& s) { int man = 0; for(int i = 0;i < 9;++i) { if(s[i] == '0') continue; int tdf = abs(s[i] - '1' - i); man += tdf/3 + tdf % 3; } return man*50; }; int F[362882]; string op[362882]; struct node { int pos; string cur; int step; int f; int hashV; friend bool operator<(const node& n1,const node& n2) { return n1.f > n2.f; }; }; string Astar() { priority_queue<node> heap; node top,temp; top.cur = beg; top.pos = xpos; top.step = 0; top.f = manhattan(beg) + top.step; top.hashV = hashfun(beg); F[top.hashV] = top.f * 10 + 1; op[top.hashV] = ""; heap.push(top); while(!heap.empty()) { top = heap.top(); heap.pop(); if(F[top.hashV]/10 != top.f) continue; if(top.cur == des) return op[top.hashV]; F[top.hashV] = top.f * 10 + 2; for(int i = 0;i < 4;++i) { if(dxdy[top.pos][i] < 0) continue; temp.pos = dxdy[top.pos][i]; temp.cur = top.cur; temp.cur[top.pos] = temp.cur[temp.pos]; temp.cur[temp.pos] = '0'; temp.hashV = hashfun(temp.cur); temp.f = manhattan(temp.cur) + top.step + 1; temp.step = top.step + 1; if(F[temp.hashV] == 0) { heap.push(temp); F[temp.hashV] = temp.f * 10 + 1; op[temp.hashV] = op[top.hashV] + dir[i]; } else if(F[temp.hashV]%10 == 1 && F[temp.hashV]/10 > temp.f) { heap.push(temp); F[temp.hashV] = temp.f * 10 + 1; op[temp.hashV] = op[top.hashV] + dir[i]; } } } }; int main() { while(cin>>beg[0]) { cin>>beg[1]>>beg[2]>>beg[3]>>beg[4]>>beg[5]>>beg[6]>>beg[7]>>beg[8]; for(xpos = 0;xpos < 9;++xpos) { if(beg[xpos] == 'x') { beg[xpos] = '0'; break; } } memset(F,0,sizeof(F)); if(count(beg)&1) printf("unsolvable/n"); else { string s = Astar(); int len = s.length(); for(int i = 0;i < len;++i) printf("%c",s[i]); printf("/n"); } } return 0; }