POJ 1077 解题报告

采用最简单的宽搜做法,用一个hash表保存已经搜索过的节点。状态值使用一个int,每三位对应序列中的一个数,最后五位存放0的位置,0和8都用000表示。在C++中会超时,在G++中9232K 782MS ,可以说效率是比较低的。

 

使用双向bfs,可以大大提高效率。注意我这里双向广度的循环是逐层的。我原来以为,如果不用逐层,两个搜索队列的层数可能不平衡,效率可能会降低,其实不逐节点扩展速度也不差。每次扩展完一层后都在队列中加个0标志。以下是双向bfs实现,结果用了47ms。

 

#include <cstdio> #include <queue> #include <deque> #include <algorithm> #include <hash_map> /*#include <ext/hash_map>*/ using namespace std; using namespace stdext;/*using namespace __gnu_cxx;*/ int target = 0x29cbb808; queue<int> q1, q2; hash_map<int,int> h1, h2; int getdisorder(int* seq, int num) { int ret = 0, i, j; //排序,从而计算出逆序对个数 for (i = num - 1; i > 0; --i) for (j = 0; j < i; ++j) if (seq[j] > seq[j + 1]) { swap(seq[j], seq[j + 1]); ++ret; } return ret; } //swappos > zpos inline int getchild_1(int node, int zpos, int swappos) { int val = (node >> (29 - 3 * swappos)) & 7; return ( node & (((1 << (3 * zpos)) - 1) << (32 - 3 * zpos)) ) | (val << (29 - 3 * zpos)) | ( node & (((1 << (3 * (swappos - zpos) - 3)) - 1) << (32 - 3 * swappos)) ) | ( node & (((1 << (24 - 3 * swappos)) - 1) << 5) ) | swappos; } //swappos < zpos inline int getchild_2(int node, int zpos, int swappos) { int val = (node >> (29 - 3 * swappos)) & 7; return ( node & (((1 << (3 * swappos)) - 1) << (32 - 3 * swappos)) ) | ( node & (((1 << (3 * (zpos - swappos) - 3)) - 1) << (32 - 3 * zpos)) ) | (val << (29 - 3 * zpos)) | ( node & (((1 << (24 - 3 * zpos)) - 1) << 5) ) | swappos; } inline int getdownchild(int node) { int zpos = node & 0x1f; return (zpos / 3 != 2) ? getchild_1(node, zpos, zpos + 3) : 0; } inline int getupchild(int node) { int zpos = node & 0x1f; return (zpos / 3 != 0) ? getchild_2(node, zpos, zpos - 3) : 0; } inline int getrightchild(int node) { int zpos = node & 0x1f; return (zpos % 3 != 2) ? getchild_1(node, zpos, zpos + 1) : 0; } inline int getleftchild(int node) { int zpos = node & 0x1f; return (zpos % 3 != 0) ? getchild_2(node, zpos, zpos - 1) : 0; } int uptracenode(int node, int direct) { if (direct == 'u') { return getupchild(node); } else if (direct == 'd') { return getdownchild(node); } else if (direct == 'l') { return getleftchild(node); } else { return getrightchild(node); } } int downtracenode(int node, int direct) { if (direct == 'u') { return getdownchild(node); } else if (direct == 'd') { return getupchild(node); } else if (direct == 'l') { return getrightchild(node); } else { return getleftchild(node); } } void downtrace(hash_map<int,int>::iterator itr) { if (itr->second) { downtrace(h2.find(downtracenode(itr->first, itr->second))); putchar(itr->second); } } void uptrace(hash_map<int,int>::iterator itr) { while (itr->second) { putchar(itr->second); itr = h1.find(uptracenode(itr->first, itr->second)); } } bool solvable(int puzzle) { //计算puzzle中的逆序数是否为偶数 int seq[9], tmp; //从高到低依次取3位(0变成8),取9次 for (int i = 0; i < 9; ++i) { tmp = (puzzle >> (29 - 3 * i) ) & 7; seq[i] = tmp ? tmp : 8; } //取出最后5位,将该位置的0与数组最后一个数交换 int pos = puzzle & 0x1f; //将后面的数往前提 for (int i = pos; i < 9; ++i) { seq[i] = seq[i + 1]; } //对前面的8个数计算逆序数 return !(getdisorder(seq, 8) % 2); } void search(int puzzle) { if (puzzle == target) { return; } if (!solvable(puzzle)) { printf("unsolvable/n"); return; } q1.push(target); q1.push(0); /*h1.resize(362880);*/ h1[target] = 0; q2.push(puzzle); q2.push(0); /*h2.resize(362880);*/ h2[puzzle] = 0; int node, child; hash_map<int, int>::iterator itr; bool trace_case; int direct; for (; ;) { while (node = q1.front()) { q1.pop(); child = getupchild(node); if (child) { itr = h2.find(child); if (itr != h2.end()) { direct = 'd'; trace_case = 0; goto hell; } if (h1.find(child) == h1.end()) { h1.insert(make_pair(child, 'd')); q1.push(child); } } child = getdownchild(node); if (child) { itr = h2.find(child); if (itr != h2.end()) { direct = 'u'; trace_case = 0; goto hell; } if (h1.find(child) == h1.end()) { h1.insert(make_pair(child, 'u')); q1.push(child); } } child = getleftchild(node); if (child) { itr = h2.find(child); if (itr != h2.end()) { direct = 'r'; trace_case = 0; goto hell; } if (h1.find(child) == h1.end()) { h1.insert(make_pair(child, 'r')); q1.push(child); } } child = getrightchild(node); if (child) { itr = h2.find(child); if (itr != h2.end()) { direct = 'l'; trace_case = 0; goto hell; } if (h1.find(child) == h1.end()) { h1.insert(make_pair(child, 'l')); q1.push(child); } } } q1.pop(); q1.push(0); while (node = q2.front()) { q2.pop(); child = getupchild(node); if (child) { itr = h1.find(child); if (itr != h1.end()) { direct = 'u'; trace_case = 1; goto hell; } if (h2.find(child) == h2.end()) { h2.insert(make_pair(child, 'u')); q2.push(child); } } child = getdownchild(node); if (child) { itr = h1.find(child); if (itr != h1.end()) { direct = 'd'; trace_case = 1; goto hell; } if (h2.find(child) == h2.end()) { h2.insert(make_pair(child, 'd')); q2.push(child); } } child = getleftchild(node); if (child) { itr = h1.find(child); if (itr != h1.end()) { direct = 'l'; trace_case = 1; goto hell; } if (h2.find(child) == h2.end()) { h2.insert(make_pair(child, 'l')); q2.push(child); } } child = getrightchild(node); if (child) { itr = h1.find(child); if (itr != h1.end()) { direct = 'r'; trace_case = 1; goto hell; } if (h2.find(child) == h2.end()) { h2.insert(make_pair(child, 'r')); q2.push(child); } } } q2.pop(); q2.push(0); } hell: if (!trace_case) { downtrace(itr); putchar(direct); uptrace(h1.find(node)); } else { downtrace(h2.find(node)); putchar(direct); uptrace(itr); } putchar('/n'); } int main() { int i,puzzle = 0,pos; char tmp[2]; for (i = 0; i < 9; ++i) { scanf("%s", tmp); puzzle <<= 3; if (tmp[0] == 'x') { pos = i; } else { puzzle |= (tmp[0] - '0') & 7; } } puzzle <<= 5; puzzle |= pos; search(puzzle); return 0; }

最有意思的是A*算法。A*算法的写法与一般的宽搜没什么区别,只是它的队列不是顺序的,而是优先队列。遍历时每次取优先级最高的节点。

优先级怎么确定呢?通常我们使用估值函数f=g+h。g是从难题节点到当前节点的遍历距离,h是当前节点到顺序节点(1 2 3 4 5 6 7 8 x)的距离估计。如果令h=0,就退化到普通的bfs。距离估计通常有两种:第一种直接比较两个节点的差异个数,第二种计算两个节点的曼哈顿距离。第二种方法使用效果较好,而且不包括数字0(即空块)的曼哈顿距离更好。估值函数中g的存在可以限制求出来的解不会太深,h可以加快搜索效率。如果给g和h加上权值,我们可以认为是求好的解(步数少)和快的解(搜索快,扩展节点少)的权衡。

还要注意g是应该在搜索过程中更新的,即发现扩展的节点比原来步数更少,应该更新。更新时不能直接修改优先队列中的数值,还应通知优先队列已经修改了,以便优先队列保持堆结构。这时判重的哈希表的节点中应该保存g。

如果完全忽略g,则哈希表中只需保存状态和方向。而队列中保存节点的曼哈顿距离。另外发现在求优先级时如果曼哈顿距离相等,再比较两者数字0处(即空块)的曼哈顿距离大小,小的优先会进一步减少扩展节点个数。如果数字0处曼哈顿距离仍相等,再比较二者的g大小,小的g优先,扩展节点个数会有非常微弱的减小。如果原来不计算g,为了微弱的性能提升,现在要比较还要维护,有点得不偿失。随机测试一千个序列,得到的平均扩展节点个数如下:

双向宽度优先搜索                              661

仅比较曼哈顿距离                              236

还比较数字0出的曼哈顿距离                173

还比较g                                           168

 

以下是比较曼哈顿距离再比较数字0出的曼哈顿距离的做法,在POJ上提交,620K 0MS。很奇怪的是代码提交到hdu1043和ustc1012都是错误的,以至于后来自己写了个special judge,对9!的全排列一一做了测试,也没发现问题。

#include <cstdio> #include <queue> /*#include <ext/hash_map>*/ #include <hash_map> int target = 0x29CBB808; /* { {1, 2, 3, 4, 5, 6, 7, 0, 0}, 8, }; */ using namespace std; /*using namespace __gnu_cxx;*/ using namespace stdext; hash_map<int, int> h; //记录各个位置之间的曼哈顿距离 int dist[9][9] = { 0,1,2,1,2,3,2,3,4, 1,0,1,2,1,2,3,2,3, 2,1,0,3,2,1,4,3,2, 1,2,3,0,1,2,1,2,3, 2,1,2,1,0,1,2,1,2, 3,2,1,2,1,0,3,2,1, 2,3,4,1,2,3,0,1,2, 3,2,3,2,1,2,1,0,1, 4,3,2,3,2,1,2,1,0, }; struct tagQData { int node; short zmanhattan;//x位置的曼哈顿距离 short other;//其他位置的曼哈顿距离之和 }; struct cmp { bool operator()(tagQData& lhs, tagQData& rhs) { //注意是小根堆,必须用> if (lhs.other == rhs.other) { return lhs.zmanhattan > rhs.zmanhattan; } return lhs.other > rhs.other; } }; priority_queue<tagQData, vector<tagQData>, cmp> q; int getdisorder(short seq[], int num) { //在冒泡排序过程中计算逆序对总数 int i,j,ret = 0; for (i = num - 1; i > 0; --i) for (j = 0; j < i; ++j) { if (seq[j] > seq[j + 1]) { swap(seq[j], seq[j + 1]); ++ret; } } return ret; } bool solvable(int puzzle) { //通过计算逆序数是否为偶数判断是否可解,先把0调出 short seq[9]; int pos = puzzle & 0x1f; puzzle >>= 5; for (int i = 8; i >= 0; --i) { seq[i] = puzzle & 7; seq[i] = seq[i] + 8 - ((seq[i] + 7) & ~7);//0变成8,其余不变 puzzle >>= 3; } for (int i = pos; i < 8; ++i) { seq[i] = seq[i + 1]; } return !(getdisorder(seq, 8) & 1); } short manhattan(int puzzle, short& zmanhattan) { int pos = puzzle & 0x1f, num, ret = 0, i; puzzle >>= 5; for (i = 8; i > pos; --i,puzzle >>= 3) { num = puzzle & 7; num = num + 8 - ((num + 7) & ~7);//0变为8 --num; ret += dist[num][i]; } zmanhattan = dist[pos][8]; for (--i; i >= 1; --i,puzzle >>= 3) { num = puzzle & 7; num = num + 8 - ((num + 7) & ~7);//0变为8 --num; ret += dist[num][i]; } return ret; } //swappos > zpos #define GET_CHILD_1 / val = (node >> (29 - 3 * swappos)) & 7; / return ( node & (((1 << (3 * zpos)) - 1) << (32 - 3 * zpos)) ) / | (val << (29 - 3 * zpos)) / | ( node & (((1 << (3 * (swappos - zpos) - 3)) - 1) << (32 - 3 * swappos)) ) / | ( node & (((1 << (24 - 3 * swappos)) - 1) << 5) ) / | swappos; //swappos < zpos #define GET_CHILD_2 / val = (node >> (29 - 3 * swappos)) & 7; / return ( node & (((1 << (3 * swappos)) - 1) << (32 - 3 * swappos)) ) / | ( node & (((1 << (3 * (zpos - swappos) - 3)) - 1) << (32 - 3 * zpos)) ) / | (val << (29 - 3 * zpos)) / | ( node & (((1 << (24 - 3 * zpos)) - 1) << 5) ) / | swappos; int getchild(int node, int direct) { int zpos = node & 0x1f, swappos, val; if (direct == 'u') { if (zpos < 3) { return 0; } swappos = zpos - 3; GET_CHILD_2 } else if (direct == 'd') { if (zpos >= 6) { return 0; } swappos = zpos + 3; GET_CHILD_1 } else if (direct == 'l') { if (!(zpos % 3)) { return 0; } swappos = zpos - 1; GET_CHILD_2 } else { if (zpos % 3 == 2) { return 0; } swappos = zpos + 1; GET_CHILD_1 } } void uptrace(hash_map<int, int>::iterator itr) { int direct = itr->second; if (!direct) { return; } int di; if (direct == 'u') { di = 'd'; } else if (direct == 'd') { di = 'u'; } else if (direct == 'l') { di = 'r'; } else { di = 'l'; } uptrace( h.find(getchild(itr->first, di)) ); putchar(direct); } void uptrace(int node, int direct) { uptrace(h.find(node)); putchar(direct); putchar('/n'); } void AStar(int puzzle) { if (puzzle == target) { return; } if (!solvable(puzzle)) { printf("unsolvable/n"); return; } tagQData fill; fill.node = puzzle; fill.other = manhattan(puzzle, fill.zmanhattan); q.push(fill); h[puzzle] = 0; int node,child,direct; for (; ;) /*一定不为空*/ { node = q.top().node; q.pop(); if (child = getchild(node, 'u')) { if (child == target) { direct = 'u'; break; } if (h.find(child) == h.end()) { h[child] = 'u'; fill.node = child; fill.other = manhattan(child, fill.zmanhattan); q.push(fill); } } if (child = getchild(node, 'd')) { if (child == target) { direct = 'd'; break; } if (h.find(child) == h.end()) { h[child] = 'd'; fill.node = child; fill.other = manhattan(child, fill.zmanhattan); q.push(fill); } } if (child = getchild(node, 'l')) { if (child == target) { direct = 'l'; break; } if (h.find(child) == h.end()) { h[child] = 'l'; fill.node = child; fill.other = manhattan(child, fill.zmanhattan); q.push(fill); } } if (child = getchild(node, 'r')) { if (child == target) { direct = 'r'; break; } if (h.find(child) == h.end()) { h[child] = 'r'; fill.node = child; fill.other = manhattan(child, fill.zmanhattan); q.push(fill); } } } uptrace(node, direct); //printf("%d", h.size()); } int main() { char tmp[2]; short pos; int puzzle; for (int i = 0; i < 9; ++i) { scanf("%s", tmp); puzzle <<= 3; if (tmp[0] == 'x') { pos = i; } else { puzzle |= (tmp[0] - '0') & 7; } } puzzle <<=5; puzzle |= pos; AStar(puzzle); return 0; }