pku1077

Kevin_Zhang — Sat, 21 Aug 2010 11:57:00 GMT

http://blog.163.com/sentimental_man/blog/static/73001618200881405851176/
��介：
         所谓八数码问题是指�q�样一�U�游戏：��分别标有数�?�Q?�Q?�Q?#8230;�Q?的八块正方�Ş数码牌�Q意地攑֜�一�?×3的数码盘上。放牌时要求不能重叠。于是，�?×3的数码盘上出��C��一个空根{��现在要求按照每�ơ只能将与空格相�ȝ��数码牌与�I�格交换的原则，��Q意摆攄��数码盘逐步摆成某种�Ҏ��的排列。如下图表示了一个具体的八数码问题求解�?br>
问题分析�Q?/span>
         首先�Q�八数码问题包括一个初始状�?START) 和目标状�?END)�Q�所谓解八数码问题就是在两个状态间��L��一�p�d��可过渡状态（START->STATE1->STATE2->...->END�Q�。这个状态是否存在就是我们要解决的第一个问题：

Q1�Q�每一个状态及每一�ơ操作的表示�Ҏ��Q?/span>
         有许多表�C�方法，比如一�?*3的八数码盘可以压�~�成一个int��D��C�，但不适用�?5 puzzle或大�? 的puzzle问题。如果对�I�间要求很高�Q�应该还可以再压�~�。本文采用一个int表示的方法�?br>         表示�Ҏ��如下�Q�由于int的表�C��围大�?e9�Q�所以我们取一个int的低9位，��Z��方便��L��I�格的位�|�，int的个位我们用来放�I�格的位�|�（1-9�Q�。而前8位，按照行从上到下，列从左到右的��序依次记录对应位置上的数字。例如：
         可以表示�?2 3 1 5 8 4 6 7 5 �Q�个位的5表示�I�格在第5位，前八位数按顺序记录。坐标�{换公式�ؓ�Q?br>     num�Q�压�~�后的int�Q?x y�Q�求x行y�?1记�v�Q?e(n)�?1�?0的n��?br>     int temp=(x-1)*3+y
     if   temp > num%10 then return (num / 1e(9-temp+1)) %10
     else return (num / 1e(9-temp) )%10

     ��Z��方便本文介绍�Q�取目标状态�ؓ�Q? 2 3 4 5 6 7 8 9 �?->

         操作本文�?u r d l 分别表示 �I�格的向�?向右向下向左四个操作。比如，在简介中的图包括两步操作 l d �Q�可能与�q�x��玩这�c�L��戏的习惯不符合，但这是�ؓ了和ACM例题相统一�?br>
     对应圎ͼ�每种操作引�v的状态变化如下：
     r �Q�num�?+              l �Q�num�?-
     u �Q�有点复�?br>     int t0 = 9-num%10 + 1
     int t1 = num / 1e(t0)
     int t2 = t1%1000
     t1= t1- t2 + (t2 % 100) * 10 + t2 / 100
     t1*= 1e(t0)
     return (t1 + ( (num % t0) - 3))
     d �Q�return前面同u操作�Q?return�q�回   (t1 + ( (num % t0) + 3))

Q2�Q�判断是否存在中间状态��START 到达END�Q?/span>
         用组合数学的�Ҏ��可以快速地�q�行判断�Q�例如SOJ 2061�?2360题中都是关于此类的问题。但八数码的判断�Ҏ��比他们简单多了�?br>
         本文用的�Ҏ��是计��排列的逆序数��|��? 3 1 5 8 4 6 7 5 ��Z��子，5表示的是�I�格�Q�不计算�Q�那么求23158467 的逆序��gؓ
         0 + 0 + 2 (1<2 1<3 ) + 0 + 0 + 1 ( 4<5 ) + 1 ( 6<8 ) + 1 ( 7<8 ) = 5
目标状�? 2 3 4 5 6 7 8 9 的逆序自然��是0�?br>
两个状态之间是否可达，可以通过计算两者的逆序��|��若两者奇偶性相同则可达�Q�不然两个状态不可达�?br>
��单证明一下：
         l �?r 操作�Q�不会媄响状态的逆序��|��因�ؓ只会改变个位敎ͼ��I�格的位�|�）�?br>         u和d操作是��某个位置的数�?�?左移两位。由于数字序列的每一�ơ移动会佉K��序值奇偶性改变，所�?nbsp;            �U�d��两次后奇偶性不变�?br>         所以四个操作均不会影响序列的奇偶性�?br>
Q3�Q�如何寻找一�p�d��的中间状态及遇到的问题？
         要寻找这一�p�d��中间状态的�Ҏ��是搜索，但搜索很�Ҏ��遇到旉��和空间上的问题。以下就是搜索的基本原理�Q?br>
         �? 3 7 2 4 6 8 5 2 状态可以衍生三个状态，假如选择�? 2 3 7 4 6 8 5 5 �Q�则又衍生三个状态，�l�箋按某�{�略�q�行选择�Q�一直到衍生出的新状态�ؓ目标状态END 为止�?br>�Ҏ��看出�Q�这��L��搜烦�c�M��于从树根开始向茎再向叶搜烦目标叶子一��L��树型状。由于其规模的不断扩大，其叶子也愈加茂密�Q�最�l�的规模会大到无法控制。这样在�I�间上会大大加大搜烦隑ֺ��Q�在旉��上也要消耗许多�?br>
在普通搜索中遇到以下问题�Q?br>        a   搜烦中易出现循环�Q�即讉K��某一个状态后又来讉K��该状态�?br>        b 搜烦路径不佳便无法得到较好的中间状态集�Q�即中间状态集的元素数量过大）�?br>        c 搜烦�q�程中访问了�q�多的无用状态，�q�些状态对最后的�l�果无帮助�?br>

         以上三个问题中，a��命问题，应该它可能导致程序死循环�Q�b和c是非致命的，但若不处理好可能��D��性能急剧下降�?br>

Q4�Q�怎样避免重复讉K��一个状态？
         最直接的方法是记录每一个状态访问否�Q�然后再衍生状态时不衍生那些已�l�访问的状态了。思想是，�l�每个状态标��C��个flag�Q�若该状态flag = true则不衍生�Q�若为false则衍生�ƈ修改flag为true�?br>在某些算法描�q�里�Q�称有两个链表，一个�ؓ�z�链表（待访问）�Q�一个�ؓ死链表（讉K��完）。每一�ơ衍生状态时�Q�先判断它是否已在两个链表中�Q�若存在�Q�则不衍生；若不存在�Q�将其放入活链表。对于被衍生的那个状态，攑օ�死链表�?br>
         ��Z��记录每一个状态是否被讉K��q�，我们需要有��_��的空间。八数码问题一共有9!�Q�这个数字�ƈ不是很大�Q�但�q�面而来的另一个问题是我们如何快速访问这些状态，如果是单�U�用链表的话�Q�那么在规模相当大，查找的状态数目十分多的时候就不能快速找到状态，其复杂度为O(n),��Z��解决�q�个问题�Q�本文将采用哈希函数的方法，使复杂度减�ؓO(1)�?br>         �q�里的哈希函数是用能对许多全排列问题适用的方法。取n!为基敎ͼ�状态第n位的逆序��gؓ哈希值第n位数。对于空��|��取其�Q?-位置�Q�再乘以8!。例如，1 3 7 2 4 6 8 5 8 的哈希值等于：
0*0! + 0*1! + 0*2! + 2*3! + 1*4! + 1*5! + 0*6! + 3*7! + (9-8)*8! = 55596 <9!

         具体的原因可以去查查一些数学书�Q�其�? 2 3 4 5 6 7 8 9 的哈希值是0 最��，8 7 6 5 4 3 2 1 0 的哈希值是�Q?!-1�Q�最大，而其他值都�? 刎ͼ�9!-1�Q?中，且均唯一�?br>
Q5�Q�如何��搜烦只求得最佳的解？
         普通的搜烦�U�CؓDFS�Q�深度优先搜索）。除了DFS�Q�还有BFS�Q�从概念上讲�Q�两者只是在扩展时的方向不同�Q�DFS向深扩张�Q�而BFS向广扩张。在八数码问题的解集树中�Q�树的深度就表示了从初始态到目标态的步数�Q�DFS一呛_��深，所以很�Ҏ��扑և�深度较大的解�?br>         BFS可以保证解的深度最��，因�ؓ在未��同一深度的状态全部访问完前，BFS不会去访问更��q��状态，因此比较适合八数码问题，臛_��能解��x��最佌��的难题�?br>
         但是BFS和DFS一样不能解决问题c �Q�因为每个状态都需要扩张，所以广搜很�Ҏ��使待搜状态的数目膨胀。最�l�媄响效率�?br>

Q6�Q�该如何减少因广搜所扩张的与目标状态及解无关的状态？
         前面所说的都是从START状态向END状态搜索，那么�Q�将END状态与START状态倒一下，其实会有另一条搜索�\径（Q8�{�略三讨论）�Q�但��单的交换END与START�q�不能羃��状态膨胀的规模。我们可以将正向与反向的搜烦�l�合��h��Q�这��是双向�q�度搜烦�?br>         双向�q�搜是指同时从START和END两端搜，当某一端所要访问的一个状态是被另一端访问过的时候，��x��到解�Q�搜索结束。它的好处是可以避免�q�搜后期状态的膨胀�?br>采用双向�q�度搜烦可以��空间和旉��节省一半！

Q7�Q�决定一个快的检索策略？
         双向�q�搜能大大减��时间和�I�间�Q�但在有的情况下我们�q�不需要空间的节省�Q�比如在Q4中已�l�决定了我们需要��用的�I�间�?�Q�，所以不需要节省。这��h��们可以把重点攑֜�旉��的羃短上�?br>         启发式搜索是在�\径搜索问题中很实用的搜烦方式�Q�通过设计一个好的启发式函数来计��状态的优先�U�，优先考虑优先�U�高的状态，可以提早搜烦到达目标态的旉��。A*是一�U�启发式搜烦的，他的启发式函数f ' ()=g' () + h' () 能够应用到八数码问题中来�?br>         g' () ----- 从�v始状态到当前状态的实际代�hg*()的估计��|��g' () >= g*()
         h' () ----- 从当前状态到目标状态的实际代�hh*()的估计��|��h' () <= h*()
注意两个限制条�g�Q?br>         �Q?�Q�h' () <= h*()   �Q?�Q��Q意状态的f '()值必��d��于其父状态的f '()��|��即f '()单调递增�?br>
         其中�Q�g' () 是搜索的深度�Q?h' () 则是一个估计函敎ͼ�用以估计当前态到目标态可能的步数。解八数码问题时一般有两种估计函数。比较简单的是difference ( Status a,   Status b )�Q?其返回值是a 和b状态各位置上数字不同的�ơ数。另一�U�比较经典的是曼哈顿距离    manhattan ( Status a, Status b )�Q�其�q�回的是各个数字从a的位�|�到b的位�|�的距离�Q�见例子�Q��?br>
例如状�?1 3 7 2 4 6 8 5 2 和状�?1 2 3 4 5 6 7 8 9 的difference �?�Q�不含空��|��。而他的manhattan 距离是：
1 (7d一��? + 1 (2u一��? + 2 (4l两次) + 3 (6r两次u一��? + 2 (5u一�ơl一��? = 9
单个数字的manhattan应该��于5�Q�因为对角的距离�?�Q�若大于4则说明计��有误�?br>
         无论是difference�q�是manhattan�Q�估计�ؓ��小��接�q�END�Q�所以优先��高�?br>         在计��difference和manhattan�Ӟ��推荐都将�I�格忽略�Q�因为在difference中空格可有可无，�Ҏ��体搜索媄响不大�?br>
         本文后面的实现将使用manhattan 不计�I�格的方法。其实，每移动一步，不计�I�格�Q�相当于�U�d��一个数字。如果每�ơ移动都是完��的�Q�即把一个数字归位，那么START态到END态的距离��是manhattan。反�q�来��_��manhattan是START到END态的臛_��走的步数�?br>         回到f '()=g' ()+ h' ()�Q�其实广度搜索是h' ()=0的一�U�启发式搜烦的特例，而深度搜索是    f ' ()=0 的一般搜索。h' ()对于优化搜烦速度有很重要的作用�?br>
Q8�Q�能否进一步优化检索策略？
         �{�案是肯定的�?br>         A*搜烦�{�略的优劣就是看h' ()的决定好坏。前面列举了两个h' ()的函敎ͼ�但光有这两个是不够的。经�q�实验分析，在f '()中，g '()军_��的是START态到END态中求得的解距离最优解的距��R�?而h' () 能媄响搜索的速度�?br>         所以优化的�W�一条策略是�Q�放大h' ()�Q�比如，让h '()= 10* manhattan()�Q�那么f '()= g' ()+10*manhattan()�Q�可能提高搜索速度。可惜的是所得的解将不再会是最优的了�?br>         ��Z��么放大h'()能加快搜索速度�Q�我们可以想象一下，h'()描述的是本状态到END态的估计距离�Q�估计距��越短自然快一点到达END态。�?g' ()描述的是目前的深度，攑֤�h' ()的目的是��量忽略深度的因素，是一�U�带�{�略的深搜，自然速度会比�q�搜和深搜都快，而因为减��考虑了深度因素，所以离最优解��p��来越�q�了。关于h' ()攑֤�多少�Q�是很有��的问题�Q�有兴趣可以做些实验试试�?br>
         �W�二条是更新待检查的状态，�׃��A*搜烦会需要一个待��查的序列。首先，在Q4已经提到用哈希避免重复访问同一状态。而在待检查队列中的状态是未完成扩张的状态，如果出现了状态相同但其g '()比原g '()��的情况，那么我们更希望的是搜索新状态，而不是原状态。这��P��在待��查队列中出现重复状态时�Q�只需更新其g'() ��可以了�?br>
         �W�三条是注意实现�E�序的方法，在�v初我用sort排序f '()后再扑և�权值最大的状态，而后发现用make_heap要更快。想一惻I��׃��需要访问的接点较多�Q�待讉K��队列一大那么自然反复排序对速度会有影响�Q�而堆操作则比排序更好。另一�Ҏ��Q�实现更新待��查队列时的搜索也要用比较好的�Ҏ��实现。我在JAVA的演�C�程序中用的PriorityQueue�Q�可是结果不是很令�h满意�?br>
         �W�四条优化策略是使用IDA*的算法，�q�是A*��法的一�U�，ID名�ؓIterative deepening是�P代加��q��意思。思想是如下：
��Z��准备一个记录一�ơ��@环最��值的temp=MAX, h' �?manhattan距离
     先估��从START态到END态的h'() 记录为MIN�Q�将START攑օ�待访问队�?br>     ��d��队列下一个状态，到队列尾则GOTO�?br>     若g'() > MIN GOTO �?br>     若g'() + h'()   > MIN 是否为真�Q�真GOTO ⑥，�?GOTO �?br>     扩展该状态，�q�标记此状态已讉K��。找到END态的话就�l�束该算法。GOTO �?br>     temp = min(manhattan , temp),GOTO �?br>     若无扩展�q�状态，MIN=temp �Q�ID的意思在�q�里体现�Q�从头开始��@环GOTO �?br>
         �W�五条优化策略本�w�与搜烦无关�Q�在做题时也没能帮上忙，不过从理��Z��讲是有参考�h值的。记得Q6中介�l�的从END开始搜起吗�Q�如果我们的��d��是对多个START 与END�q�行搜烦�Q�那么我们可以在每搜索完一�ơ后记录下�\径，�q�个路径很重要，因�ؓ在以后的搜烦中如果存在START和END的�\径已�l�被记录�q�了�Q�那么可以直接调出结果�?br>         从END搜�v�Q�可以方便判断下一�ơ的START是否已经有�\径到END了。当前一�ơ搜索完�Ӟ��其已讉K��状态是可以直接使用的，若START不在其中�Q�则从待讉K��的状态链表中按搜索策略找下一个状态，�{�于接着上一�ơ的搜烦�l�果开始找�?br>         之所以没能在速度上帮上忙�Q�是因�ؓ�q�个优化�{�略需要加大g' ()的比重，否则很容易出现深度相当大的情况，�׃��前一�ơ搜索的�{�略与下一�ơ的基本无关�Q�导致前一�ơ的路径无法预料�Q�所以就会出现深度过大的情况。解��x��法是加大g' ()�?br>�{�略五类似给�E�序加一个缓冲区�Q�避免重复计��。如果要做八数码的应用，�~�冲��Z��帮上忙的�?br>
Q10�Q�怎样记录扑ֈ�的�\径？
         当找到解的时候我们就需要有�c�M��回退的工作来整理一条解路径�Q�由于��用了不是��单的DFS�Q�所以不能借助通过函数调用所是��用的�E�序栈�?br>         我们可以手工加一个模拟栈。在Q4中解决了哈希的问题，利用哈希表就能快速访问状态对应的��|��在这里，我们把原来的bool值改为char或其他能表示一�ơ操作（臛_��需�?�U�状态，除了u r l d 外还要能表示状态已讉K��Q�的值就行了�?br>         在搜索到解时�Q�记录下最后一个访问的状态��|��然后从读取该状态对应的操作开始，��像栈操作的退栈一��P��不停往回搜�Q�直到找到搜索�v点�ؓ止。记录好栈退出来的操作��|��是一条�\径�?

以前看了刘汝佳的书上的A*��法�Q�一直不知道怎么写，可以参考下面这个模型�?/font>

关于八数码问题可以有很多�U�实玎ͼ��q�只是其中一�U��?/font>

A*��法求八数码问题{转}

2008-05-08 09:18

�Q?�Q?用A*��法�Q?��C�h函数�?#8220;Hamilton距离”比选用“在错误方各内的数字数�?#8221;强很多�?
�Q?�Q�A*��法的关键是要能够��“扑ֈ�耗费最��的节点”�?#8220;判断是否子节点已�l�存�?#8221;的算法的效率��可能高�Q��ؓ此，�|�上不少资料��采用Binary Heap或Hash table�{�数据结构，然而单独��用�Q何一�U�数据结构，都有一定的�~�陷�Q�将Heap和Hash联合��h��使用�Q�应该可以提高不��效率。具体如下：
1。徏一张Hash表，存放没一个节点的具体信息�Q�如当前状态、父节点在表中的位置�{��?
2。open表中存放着一些节点，�q�些节点不同于Hash表中的节点，可以��它理解为是Hash表中节点的烦引，它只包含节点的估价和节点在Hash表中的位�|�，�q�些节点按估��h��列成堆（Heap�Q��?
3。没必要再徏一个closed表�?
�q�样�Q�程序的��程��可以写成：
初始化Hash表和open表；
��根节点攑օ�Hash表和open表；
found = false;
while(open表不�I? {
      从open表中得到耗费最低的节点的烦引cur; // O(1)
      从open表中删除耗费最低的节点; // O(logN)
      for 每个cur的子节点now do {
           if ( now 是目标节�?) {
                   打印输出;
                   found = true;
                   �l�束搜烦;
           }
           if( now 不在Hashtable�?) { // O(1)
                ��now插入Hashtable�? // O(1)
                ��now的烦引放入open表中; // O(logN)
           } else if( now比Hashtable中的节点�?) {
                if( 原节点在open表中 ) { // O(N)
                     用now替代原来节点; // O(1)
                     在open中push_heap来更新open表的��序; // O(logN)
                 }
           }
       }
   }
   if( !found ) 输出 "无解";
可以看到�Q�虽然查找open表中已存在的节点仍然为O(N)�Q?但是当now已存在时�Q�now比open表中节点优的概率是很��的�Q�事先用O(1)的时间判断，��可以避免用O(N)的时间来查找�Q�从而提高了效率�Q�这很像是CPU的Cache的工作原理）�?
具体�E�序如下�Q?/p>

#include "stdafx.h"
#include
#include
#include
#include
#include
using namespace std;
struct OpenNode{
int cost, point;
OpenNode(){}
OpenNode( int cost, int point ){
this->cost = cost;
this->point = point;
}
};
bool operator<( const OpenNode& a, const OpenNode& b ){
return a.cost > b.cost;
}
bool operator==(const OpenNode& a, int c){
return a.point == c;
}

struct HashNode{
char state[3][3];
int g, h, par, dir,x,y;
bool used;
HashNode(){
used=false;
}
};

int dx[] = { -1,0,1,0 },
dy[] = { 0,1,0,-1 }; // u r d l

const int HASH_SIZE = 39999;
HashNode List[HASH_SIZE];
int factorial[] = {1,1,2,6,24,120,720,5040,40320};
/*int hash( char state[3][3] ){
int ret = 0;
char *p, *q;
for(p=&state[0][0];p<=&state[2][2];p++){
int cnt = 0;
for(q=&state[0][0]; qret += factorial[&state[2][2]-p]*(*p-cnt);
}
return ret;
}*/
bool eq( char a[3][3], char b[3][3] ){
for(int i=0;i<3;i++)
   for(int j=0;j<3;j++) if( a[i][j]!=b[i][j] ) return false;
   return true;
}
int hash( char state[3][3] ){
char* p = &state[0][0];
int ret = p[0] * 7 + p[1] * 17 + p[2] * 47 + p[3] * 117 + p[4] * 217 + p[5]
   * 977 + p[6] * 1299 + p[7] * 5971 + p[8] * 7779;
ret %= HASH_SIZE;
while( List[ret].used && !eq(List[ret].state , state) )
   ret= (ret+1) % HASH_SIZE;
return ret;
}
int h( char state[3][3] ){
int ret = 0;
for(int x=0;x<3;x++)
   for(int y=0;y<3;y++) if( state[x][y]!=0 )
    ret += abs((state[x][y]-1)/3-x) +abs((state[x][y]-1)%3-y);
   return ret;
}
void output( int i ){
string res;
while(List[i].dir>=0){
   res+= List[i].dir==0?'u':List[i].dir==1?'r':List[i].dir==2?'d':'l';
   i = List[i].par;
}
reverse( res.begin(), res.end() );
cout<}
bool solvable( char state[3][3] ){
int t = 0;
for(char* i=&state[0][0];i<&state[2][2];i++)
    for(char* j=i+1;j<=&state[2][2];j++)
      if(*i!=0 && *j!=0 && *i>*j) t++;
if(t%2) return false;
return true;
}
vector open;
int main(){
string init;
getline( cin, init );
HashNode now;
int cnt=0;
for(int i=0;i   if(init[i] == 'x') {
    now.state[cnt/3][cnt%3] = 0;
    now.x = cnt /3;
    now.y = cnt %3;
    cnt++;
   } else if(init[i]!=' ') {
    now.state[cnt/3][cnt%3] = init[i] - '0';
    cnt++;
   }
}
if( !solvable(now.state) ) {
    cout<<"unsolvable"<    return 0;
}
now.g = 0;
now.h = h(now.state);
now.par = -1;
now.dir = -1;
now.used = true;
int i = hash(now.state);
List[i] = now;
open.push_back(OpenNode(now.g+now.h,i));
while(!open.empty()){
   int cur = open.front().point;
   pop_heap( open.begin(), open.end() );
   open.erase( open.end()-1 );
   for(int i=0;i<4;i++){
    now = List[cur];
    int x = now.x+dx[i];
    int y = now.y+dy[i];
    if(x<0||x>2||y<0||y>2) continue;
    swap( now.state[x][y], now.state[now.x][now.y] );
    now.x = x;
    now.y = y;
    now.h = h( now.state );
    now.g++;
    now.par = cur;
    now.dir = i;

    int hashcode = hash( now.state );
    if( now.h == 0 ){
     List[hashcode] = now;
     output( hashcode );
     return 0;
    } else if( !List[hashcode].used ){
     List[hashcode] = now;
     open.push_back( OpenNode(now.h+now.g,hashcode) );
     push_heap( open.begin(), open.end() );
    } else if( List[hashcode].g+List[hashcode].h > now.g+now.h ){
     List[hashcode] = now;
     vector::iterator it = find( open.begin(), open.end(), hashcode );
     if(it==open.end()) continue;
     push_heap( open.begin(), it+1 );
    }
   }
}
cout<<"unsolvable"<return 0;
}

Kevin_Zhang 2010-08-21 19:57 发表评论

91久久九九无码成人网站,久久久久一区二区三区,久久久精品国产sm调教网站

pku1077