Eight八位数问题2

通过程序的多次运行计算，发现此题可能有多个解！例如：

2 3 4 1 5 x 7 6 8

发现有以下三个解都符合要求：

ullddrurdllurrdlurd
dlurullddrurdllurdr
ullddrurdllurdruldr

所以大家在做的时候要注意，不一定是你的代码有问题，而是问题描述时没有说清楚！

好了，上一文章中重点介绍了该题目基于双广的解决方法，在这里我将继续介绍基于A*算法，即最优启发性算法的解法！首先，介绍下A*算法的基本知识。

 

（以下蓝色字是来源于：http://dev.gameres.com/Program/Abstract/a8first.htm，本人稍作整理）

A*算法在人工智能中是一种典型的启发式搜索算法。

 

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。

　　启发中的估价是用估价函数表示的，如：

　　f(n) = g(n) + h(n)

　　其中f(n)是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。如果说详细点，g(n)代表了搜索的广度的优先趋势。但是当h(n)>>g(n)时，可以省略g(n),而提高效率。

　启发式搜索其实有很多的算法，比如：局部择优搜索法、最好优先搜索法等等。当然A*也是。这些算法都使用了启发函数，但在具体的选取最佳搜索节点时的策略不同。象局部择优搜索法，就是在搜索的过程中选取“最佳节点”后舍弃其他的兄弟节点，父亲节点，而一直得搜索下去。这种搜索的结果很明显，由于舍弃了其他的节点，可能也把最好的节点都舍弃了，因为求解的最佳节点只是在该阶段的最佳并不一定是全局的最佳。最好优先就聪明多了，他在搜索时，便没有舍弃节点（除非该节点是死节点），在每一步的估价中都把当前的节点和以前的节点的估价值比较得到一个“最佳的节点”。这样可以有效的防止“最佳节点”的丢失。那么A*算法又是一种什么样的算法呢？其实A*算法也是一种最好优先的算法。只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：

　　f'(n) = g'(n) + h'(n)

　　这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值，h'(n)是n到目标的最断路经的启发值。由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n)，但g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。

    举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h'(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。

　　再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

基于上面理论，我用A*算法实现了八位数的求解程序，不过效率不高，用杭电数据要1100MS，还不如双广（750MS），可能还需要进一步优化！

参考代码：

#include <iostream>#include <vector>#include <algorithm>using namespace std;#define MAX362880// 9!#define END_STATE-1#define NONE_STATE0struct node{int v[9];int pos;int last;int dirflag;bool used;int g;int h;}state[MAX], endNod;int hash[MAX];int dir[4][2] = {{-1, 0},{1, 0},{0, -1},{0, 1}};vector <int> open;int gethashno(const node& val){int sum = 0, n = 1, a, i, j;for(i = 1; i < 9; ++i){n *= i;a = 0;for(j = 0; j < i; ++j){if (val.v[i] < val.v[j])++a;}sum += a*n;}return sum;}bool init(){int i;char val;for(i = 0; i < 9; ++i){if (cin>>val){if (val == 'x'){state[0].v[i] = 0;state[0].pos = i;}elsestate[0].v[i] = val-'0';}elsereturn false;}state[0].last = 0;state[0].dirflag = -1;state[0].used = false;state[0].g = 0;state[0].h = 0;for(i = 0; i < 9; ++i){if (i == 8){endNod.v[i] = 0;endNod.pos = i;}elseendNod.v[i] = i+1;}memset(hash, NONE_STATE, sizeof(hash));hash[gethashno(endNod)] = END_STATE;open.clear();return true;}bool inbound(int x, int y){if (x < 0 || x >= 3)return false;if (y < 0 || y >= 3)return false;return true;}void swap(int& v1, int& v2){int v = v1;v1 = v2;v2 = v;}bool isok(const node& val)// 当前状态（除0外）的逆序数为奇数时，它无法达到目标状态{int sum = 0, i, j;for(i = 1; i < 9; ++i){if (val.v[i] == 0)continue;for(j = 0; j < i; ++j){if (val.v[j] == 0)continue;if (val.v[i] < val.v[j])++sum;}}if (sum % 2 == 0) return true;return false;}int geth(const node& nod){int rtn = 0, x, y, x1, y1;for (x = 0; x < 3; ++x){for (y = 0; y < 3; ++y){if (nod.v[x*3+y] != 0){x1 = (nod.v[x*3+y]-1)/3;y1 = (nod.v[x*3+y]-1)%3;rtn += abs(x1-x) +abs(y1-y);}}}return rtn;}bool expend(node& subnod, int diri, int par){int x, y, pos1;x = subnod.pos/3 + dir[diri][0];y = subnod.pos%3 + dir[diri][1];if (!inbound(x, y))return false;pos1 = 3*x+y;swap(subnod.v[subnod.pos], subnod.v[pos1]);subnod.pos = pos1;subnod.dirflag = diri;subnod.used = false;++subnod.g;subnod.h = geth(subnod);subnod.last = par;return true;}bool equalnode(const node& nod1, const node& nod2){// if (nod1.pos != nod2.pos)// return false;int i;for (i = 0; i < 9; ++i){if (nod1.v[i] != nod2.v[i])return false;}return true;}void printpath(node state[], long tail){int p[1000], k = 0, i;while (tail > 0){p[k++] = tail;tail = state[tail].last;}// p[k] = 0;for (i = k-1; i >= 0; --i){switch (state[p[i]].dirflag){case 0:cout<<"u";break;case 1:cout<<"d";break;case 2:cout<<"l";break;case 3:cout<<"r";break;}}cout<<endl;}bool getOpenNode(long n, long& val){int last = open.size()-1;if (open[last] >= n)return false;val = open[last];open.erase(open.end()-1);return true;}void insertOpenNode(node state[], long val){if (open.empty()){open.push_back(val);return;}vector<int>::iterator it = open.end();int cost = state[val].g + state[val].h;while (true){if (--it == open.begin()){open.insert(it, val);break;}else{if (cost > (state[*it].g+state[*it].h))continue;open.insert(it+1, val);break;}}}void updateOpenNode(node state[], long val){vector<int>::iterator it = find(open.begin(), open.end(), val);if (it != open.end()){open.erase(it);}insertOpenNode(state, val);}void ACalc(){long cur, i, n;long hashno, stateno;node subnod;cur = 0;n = 1;if (equalnode(state[0], endNod)){cout<<endl;return;}if (!isok(state[0])){cout<<"unsolvable"<<endl;return;}hash[gethashno(state[0])] = 1;open.push_back(0);while (!open.empty()){if (!getOpenNode(n, cur))break;for (i = 0; i < 4; ++i){subnod = state[cur];if (expend(subnod, i, cur)){hashno = gethashno(subnod);stateno = hash[hashno];if (stateno == END_STATE){state[++n-1] = subnod;printpath(state, n-1);return;}else if (stateno == NONE_STATE){state[++n-1] = subnod;hash[hashno] = n;insertOpenNode(state, n-1);}else{if (state[stateno-1].g+state[stateno-1].h > subnod.g+subnod.h){state[stateno-1] = subnod;updateOpenNode(state, stateno-1);}}}}state[cur].used = true;}cout<<"unsolvable"<<endl;}int main(){while(true){if (!init())break;ACalc();} return 0;}