A*與八數碼問題

最近自學A*，看來很多神犇程式，似乎都很煩，今天我要來談談A*與8數碼問題

先給個例題：

Description

八 方塊移動遊戲要求從一個含8個數字（用1-8表示）的方塊以及一個空格方塊（用0表示）的3×3矩陣的起始狀態開始，不斷移動該空格方塊以使其和相鄰的方 塊互換，直至達到所定義的目標狀態。空格方塊在中間位置時有上、下、左、右4個方向可移動，在四個角落上有2個方向可移動，在其他位置上有3個方向可移 動。例如，假設一個3×3矩陣的初始狀態為：

另外，在所有可能的從初始狀態到目標狀態的移動路徑中，步數最少的路徑被稱為最短路徑；在上面的例子中，最短路徑為5。如果不存在從初始狀態到目標狀態的任何路徑，則稱該組狀態無解。 請設計有效的演算法找到從八方塊的某初始狀態到某目標狀態的所有可能路徑中的最短路徑。

Input

程式需讀入初始狀態和目標狀態，這兩個狀態都由9個數字組成（0表示空格，1-8表示8個數字方塊）。

Output

如果輸入資料有解，輸出一個表示最短路徑的非負的整數；如果輸入資料無解，輸出-1。

Sample Input

803214765
123804765

Sample Output

5

好了，題目看起來怎麼瞎搞都行，但是效率值得考慮。

這裡我使用最佳優先搜尋策略：

它是將深度優先和廣度優先搜尋優點進行組合而成的一種簡單方法。
在最佳優先搜尋中，有一個評價函式，總是選擇目前為止產生的所有結點中具有最小代價的結點。
因此最佳優先搜尋具有全域性觀點。

以上述問題為例：

步驟一  . 使用評價函式構造一個堆，首先構造由根結點組成的一元堆。

步驟二  . 考察堆頂元素是否為目標結點。如果是，演算法停止；否則轉向步驟三。

步驟三  . 刪除堆頂元素並擴充套件堆頂，增加該元素的後代到堆中。

步驟四  . 如果堆為空，那麼失敗；否則，轉向步驟二。

好了理論先放一邊，下面貼程式碼：

#include <iostream>
#include <vector>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <string>
#include <string.h>
#include <time.h>
#include <memory.h>
#include <stdio.h>
#include <cmath>
#include <stdlib.h>
#include <algorithm>
#include <stack>
#include <queue>
#include <cstdio>
#include <climits>

#define intmin -2147483640
#define intmax 2147483640
using namespace std;

const int Cantor_Expansion_MAXN=3628799+100;
const int Move_Tag_X[7]={0,1,-1,0};
const int Move_Tag_Y[7]={1,0,0,-1};
const int Cantor_Num[15]={0,1,2,6,24,120,720,5040,40320,362880,3628800};

typedef struct Gentil_HP_Node
{
    int num[4][4];
    int Step,Bound;
}node;

bool operator>(const struct Gentil_HP_Node a,const struct Gentil_HP_Node b)
{return a.Bound>b.Bound;}

priority_queue < node,vector<node>,greater<node> > Q;

node StMode,EdMode;
bool Cantor[Cantor_Expansion_MAXN];

int Bound_Cantor_Expansion (const node S)       //康託展開，自行百度
{
    return Cantor_Num[9]*S.num[1][1]+
           Cantor_Num[8]*S.num[1][2]+
           Cantor_Num[7]*S.num[1][3]+
           Cantor_Num[6]*S.num[2][1]+
           Cantor_Num[5]*S.num[2][2]+
           Cantor_Num[4]*S.num[2][3]+
           Cantor_Num[3]*S.num[3][1]+
           Cantor_Num[2]*S.num[3][2]+
           Cantor_Num[1]*S.num[3][3];
}

void Put_Num_Into_Node (int x,node &S)
{
     S.num[3][3]=x%10;x/=10;
     S.num[3][2]=x%10;x/=10;
     S.num[3][1]=x%10;x/=10;
     S.num[2][3]=x%10;x/=10;
     S.num[2][2]=x%10;x/=10;
     S.num[2][1]=x%10;x/=10;
     S.num[1][3]=x%10;x/=10;
     S.num[1][2]=x%10;x/=10;
     S.num[1][1]=x%10;x/=10;
}

bool Judge_In_Board (int x,int y) 
{
     if (x>=1 && y>=1 && x<4 && y<4)
     return 1;
     return 0;
}

void init ()
{
     int Stnum,Ednum;
     scanf ("%d%d",&Stnum,&Ednum);
     Put_Num_Into_Node (Stnum,StMode);
     Put_Num_Into_Node (Ednum,EdMode);
     StMode.Step=0;
}

int Bound_for_Node (node S,node T)         //估價函式
{
    int Num=0;
    if (S.num[3][3]!=T.num[3][3]) Num++;
    if (S.num[3][2]!=T.num[3][2]) Num++;
    if (S.num[3][1]!=T.num[3][1]) Num++;
    if (S.num[2][3]!=T.num[2][3]) Num++;
    if (S.num[2][2]!=T.num[2][2]) Num++;
    if (S.num[2][1]!=T.num[2][1]) Num++;
    if (S.num[1][3]!=T.num[1][3]) Num++;
    if (S.num[1][2]!=T.num[1][2]) Num++;
    if (S.num[1][1]!=T.num[1][1]) Num++;
    return Num+S.Step;
}

void Out_For_Test (const node X)
{
     cout<<X.num[1][1]<<" "<<X.num[1][2]<<" "<<X.num[1][3]<<endl;
     cout<<X.num[2][1]<<" "<<X.num[2][2]<<" "<<X.num[2][3]<<endl;
     cout<<X.num[3][1]<<" "<<X.num[3][2]<<" "<<X.num[3][3]<<endl<<endl;
}

void A_Star_Search ()
{
     node Now,next;
     StMode.Bound=(Bound_for_Node (StMode,EdMode));
     Q.push (StMode);
     Cantor[Bound_Cantor_Expansion (StMode)]=1;
     
     int ans=intmax;
     int i,j,k,sx,sy,tmp;
     while (!Q.empty ())
     {
         Now=Q.top ();Q.pop ();
         if (Now.Bound==Now.Step){ans=min (Now.Step,ans);break;}
         
         for (i=1;i<4;i++)
         for (j=1;j<4;j++)
         {
             if (Now.num[i][j]==0)
             {
                 for (k=0;k<4;k++)
                 {
                     next=Now;
                     next.Step ++;
                     sx=i+Move_Tag_X[k],sy=j+Move_Tag_Y[k];
                     if (Judge_In_Board (sx,sy))
                     {
                         next.num[i][j]+=next.num[sx][sy];
                         next.num[sx][sy]-=next.num[i][j];
                         tmp=Bound_Cantor_Expansion (next);
                         if (!Cantor[tmp])
                         {
                             Cantor[tmp]=1;
                             next.Bound=Bound_for_Node (next,EdMode);
                             Q.push (next);
                         }
                     }
                 }
                 goto Loop;
             }
         }
         Loop: ;
     }
     
     if (ans==intmax)  printf ("-1");
     else   cout<<ans;
}

int main()
{
    init ();
    A_Star_Search ();
}
 

上題中用到了一個估價函式，所謂估價函式就是對最優解的估計。

我們不妨用g(n)  表示從解空間樹的根到結點n的路徑長度。

h*(n)表示從結點n到目標結點的最優路徑長度。

結點n的代價f*(n) = g(n) + h*(n)

儘管有許多方法估計h*(n)，但A*演算法保證總是使h(n)  ≤ h*(n)。也就是說，應該使用h*(n)的保守估計。這意味著，在A*演算法中，總是使用

f(n) = g(n) + h(n) ≤ g(n) + h*(n) = f*(n) 作為估價函式。

注意到A*演算法採用最佳優先規則，這意味著在所有將擴充套件的結點中，選擇具有最小代價的結點作為下一擴充套件結點。

A*演算法具有下列終止規則：如果被選擇的結點也是目標結點，那麼這個結點代表一個最優解並且過程可被終止。

證明直接COPY一下課件：

最後給出例題一道：

今天就說到這，希望大家點個贊。