14.1    A*搜尋

A*(A star)演算法是一種很好的樹搜尋策略，在許多人工智慧的書籍中有所介紹。比如《人工智慧，一種現代方法》和《人工智慧，複雜問題求解的結構和策略》。

[i]文介紹到，A*演算法使用估價函式F(N)來估算從初始狀態S到當前狀態N，再到目標狀態T需要的最小步數。有公式：

F(N) = G(N) + H(N)

其中，G(N)是起始狀態S到當前狀態的實際代價G(N)，它比最佳路徑的代價G*(N)大。

H(N)是從當前狀態到目標狀態T的實際代價的估算值H*(N)，它比實際代價H(N)大。

對於一個起始狀態到當前狀態的實際路徑，G(N)是已經決定的。H(N)的選擇則至關重要。有兩個限制：

1. H(N)一定要小於等於當前結點N至目標結點T的實際代價。

2. 任意結點的F值必須大於其父輩狀態的F值，即F單調遞增。

當估價函式F滿足以上兩個限制條件，則啟發式搜尋演算法一定能得出問題的最優解。

14.1.1   例項

PKU JudgeOnline, 1077, Eight.

14.1.2   問題描述

15數碼遊戲就是完成類似下面的轉換的一種遊戲：

1  2 3  4    1 2  3  4   1  2  3 4    1  2 3  4

5  6 7  8    5 6  7  8   5  6  7 8    5  6 7  8

9  x 10 12   9 10  x 12    9 10 11 12    9 10 11 12

1314 11 15   13 14 11 15   13 14 x 15   13 14 15  x

           r->           d->           r->

    8數碼遊戲類似，只不過只有8個數碼而已。

    給出8數碼遊戲的一個初始狀態，求達到目標狀態的一個解，不要求是最優解。如果沒有解，輸出“unsolvable”。

14.1.3   輸入

2 3  4  1 5  x  7 6  8

1.1.4   輸出

ullddrurdllurdruldr

14.1.5   分析

《人工智慧，一種現代方法》對使用A*演算法解決八數碼問題進行了深入的分析。提出了兩種啟發函式的策略：

1. h1 = 不在位的棋子的總數。

2. h2 = 所有棋子到其目標位置的曼哈頓距離的總和。

並且通過實驗，得到h2的效能總是優於h1。

具體實現中，用到最小堆實現的優先佇列。

這裡還需要用到一個排列到整數的對映方法，以判斷一種狀態是不是已經遍歷過。一個具體的對映方法如下：

把9看成插到8的排列中，那麼有9種插法，可以把362880等分成9段，分別代表一個位置，每段遞迴處理。

令pos(a)為數字a在排列中排在a前面並且小於a的數字的個數，那麼有虛擬碼：

int n=1;

for (int i=1; i<10; i++)

{

     n+=pos(i)*(i-1)!;

}

     下面程式中int calPos1(node *temp)和int calPos(node *temp)就是兩種對映方法。

也許[ii]中介紹的排列的“反序”概念，能很好地用來解釋上面這個演算法。

14.1.6   程式

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
bool visited[362880];
#define maxNum     10000000
#define MAX        0x7F7F7F7F
struct tile{
     int x;
     int y;
};
#define maxLength 100//貌似最數碼遊戲的解長度為...
struct node{
     tile pos[3][3];
     int key;
     charop[maxLength];
     int blankX;
     int blankY;
};
nodeminHeap[maxNum];
int heapSize;
void minHeapify(int i)
{
     int l;
     int r;
     int min;
     node temp;
     l = i * 2;
     r = i * 2 + 1;
     min = i;
     if((l <=heapSize)&&
     (minHeap[l].key < minHeap[min].key)){
         min = l;
     }
     if((r <=heapSize)&&
     (minHeap[r].key < minHeap[min].key)){
         min = r;
     }
     if(min !=i)
     {
         temp = minHeap[min];
         minHeap[min] = minHeap[i];
         minHeap[i] = temp;
         minHeapify(min);
     }
}
void buildMinHeap()
{
     int i;
     for(i =heapSize / 2; i > 0; i--){
         minHeapify(i);
     }
}
nodeheapExtractMin()
{
     node min;
     if(heapSize< 1)
     {
         cout << "ERROR:no more" << endl;
     }
     min = minHeap[1];
     minHeap[1] = minHeap[heapSize];
     heapSize--;
     minHeapify(1);
     return min;
}
void heapIncreaseKey(int i, int key)
{
     node temp;
     if(key >minHeap[i].key)
     {
         cout << "ERROR:new key is smaller than current key" << endl;
     }
     minHeap[i].key = key;
     while(i> 1 && minHeap[i/2].key > minHeap[i].key)
     {
         temp = minHeap[i];
         minHeap[i] = minHeap[i/2];
         minHeap[i/2] = temp;
         i = i / 2;
     }
}
void minHeapInsert(node temp)
{
     heapSize++;
     minHeap[heapSize] = temp;
     minHeap[heapSize].key = MAX;
     heapIncreaseKey(heapSize, temp.key);
}
inline int solved(node *temp)
{
     int i, j;
     for(i = 0;i < 3; i++){
         for(j =0; j < 3; j++){
              if((*temp).pos[i][j].y!= i || (*temp).pos[i][j].x != j)
              {
                   return0;
              }
         }
     }
     return 1;
}
int adj[4][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
char operation[4] = {'l', 'r', 'u', 'd'};
int calKey(node *temp, int blankX2, int blankY2)
{
     int key;
     int x1;
     int y1;
     int x2;
     int y2;
     int blankX1= (*temp).blankX;
     int blankY1= (*temp).blankY;
     key = 1;
     x1 = abs((*temp).pos[blankY1][blankX1].x -blankX1);
     y1 = abs((*temp).pos[blankY1][blankX1].y -blankY1);
     x2 = abs((*temp).pos[blankY2][blankX2].x -blankX2);
     y2 = abs((*temp).pos[blankY2][blankX2].y -blankY2);
     key += - (x1 + y1 + x2 + y2);
     x1 = abs((*temp).pos[blankY2][blankX2].x -blankX1);
     y1 = abs((*temp).pos[blankY2][blankX2].y -blankY1);
     x2 = abs((*temp).pos[blankY1][blankX1].x -blankX2);
     y2 = abs((*temp).pos[blankY1][blankX1].y -blankY2);
     key += x1 + y1 + x2 + y2;
     return key;
}
int factorial[9] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int calPos1(node *temp)
{
     int i;
     int j;
     int x, y;
     int x1, y1;
     int temp1,temp2;
     int num;
     int sum;
     sum = 0;
     for(i = 0;i < 9; i++)
     {
         y = i / 3;
         x = i % 3;
         temp1 = (*temp).pos[y][x].x +(*temp).pos[y][x].y * 3;
         num = 0;
         for(j =0; j < i; j++)
         {
              y1 = j / 3;
              x1 = j % 3;
              temp2 = (*temp).pos[y1][x1].x +(*temp).pos[y1][x1].y * 3;
              if(temp2< temp1)
              {
                   num++;
              }
         }
         sum += (temp1 - num) * factorial[9 - i- 1];
        
     }
     return sum;
}
int calPos(node *temp)
{
    inti,j,k=0,b[9],ret=0,num=0;
    for(i=0;i<3;i++)
        for(j=0;j<3;j++)
            b[k++]=(*temp).pos[i][j].x +(*temp).pos[i][j].y * 3;
    for(i=0;i<9;i++)
    {
        num=0;
        for(j=0;j<i;j++)
            if(b[j]>b[i])  num++;
        ret+=factorial[i]*num;
    }
    return ret;
}
int main()
{
     int i;
     int j;
     int x;
     int y;
     int blankX;
     int blankY;
     char c;
     int length;
     node insertNode;
     node temp;
     int pos;
     bool find;
     insertNode.key = 0;   
     for(i = 0;i < 3; i++){
         for(j =0; j < 3; j++){
              cin >> c;
              if(c== 'x'){
                   insertNode.blankY = i;
                   insertNode.blankX = j;
                   insertNode.pos[i][j].x = 2;
                   insertNode.pos[i][j].y = 2;
              }else{
                   x = c - '1';
                   y = x / 3;
                   x = x % 3;
                   insertNode.pos[i][j].x = x;
                   insertNode.pos[i][j].y = y;
              }
              insertNode.key +=abs(insertNode.pos[i][j].x - j);
              insertNode.key +=abs(insertNode.pos[i][j].y - i);
         }
     }
     heapSize = 0;
     for(i = 0;i < maxLength; i++)
     {
         insertNode.op[i] = '\0';
     }
     memset(visited, 0, sizeof(visited));
     pos = calPos(&insertNode);
     visited[pos] = 1;
     minHeapInsert(insertNode);
     find = 0;
     int count =0;
     while(heapSize> 0){
         if(heapSize> maxNum)
         {
              cout <<endl<< "Too large" << endl;
              return-1;
         }
         temp = heapExtractMin();
         if(solved(&temp)== 1)
         {
              find = 1;
              cout << temp.op <<endl;
              break;
         }
         for(i =0; i < 4; i++){
              blankX = temp.blankX;
              blankY = temp.blankY;
              y = blankY + adj[i][0];
              x = blankX + adj[i][1];
              count++;
              if(x< -1 || x > 3 || y < -1 || y > 3)
              {
                   while(1)
                   {}
              }
              if(x< 0 || y < 0 || x > 2 || y > 2)
              {
                   continue;
              }
              insertNode = temp;
              insertNode.pos[y][x].x =temp.pos[blankY][blankX].x;
              insertNode.pos[y][x].y =temp.pos[blankY][blankX].y;
              insertNode.pos[blankY][blankX].x =temp.pos[y][x].x;
              insertNode.pos[blankY][blankX].y =temp.pos[y][x].y;
              pos = calPos(&insertNode);
              if(visited[pos]!= 0){
                   continue;
              }
              visited[pos] = 1;
              insertNode.key +=calKey(&temp, x, y);
              insertNode.blankX = x;
              insertNode.blankY = y;
              length = strlen(temp.op);
              insertNode.op[length] =operation[i];
              minHeapInsert(insertNode);
         }
     }
     if(find ==0)
     {
         printf("unsolvable\n");
     }
     return 1;
}

A*演算法減少儲存需求的最簡單的方法就是將迭代深入的思想用在啟發式搜尋上，形成迭代深入A*演算法，即IDA*。

使用BFS搜尋需要實用一個佇列，這個佇列如果過大就可能超出記憶體限制。用DFS代替BFS，可以減少儲存需求。

IDA*演算法實際上是在迭代加深的深度優先搜尋的基礎上進行的一種改進。迭代加深的深度優先搜尋使用當前搜尋深度來判斷是否停止搜尋，而IDA*演算法則使用A*演算法的估價函式F(N) = G(N) + H(N)來判斷是否停止搜尋。可以知道，此時的G(N)就是當前搜尋深度，H(N)則是對於從當前結點N至目標結點T的實際代價一種樂觀估計。說H(N)樂觀，是因為在設計估價函式的時候，H(N)被約束為小於等於實際代價。由此可知，相對於樸素的迭代加深的深度優先搜尋，IDA*演算法省去了一些不必要的搜尋。

14.2.1   例項

PKU JudgeOnline, 2286, The Rotation Game.

14.2.2   問題描述

如上圖一種遊戲，給定初始狀態，通過拉動A到H的，對該行或列進行旋轉。目標是使得中間的八個數字相等。

輸出字典序最小的最優解的旋轉過程，及其最終狀態時中間的數字。

14.2.3   輸入

11 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3

11 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3

0

14.2.4   輸出

AC

2

DDHH

2

14.2.5   分析

對搜尋的深度給一個步數限制。每次在狀態空間裡進行DFS搜尋的時候，如果遇見當前狀態決定了已經不可能在限制內找到解，就返回，而不再搜尋其子狀態。如果這次DFS沒找到，就繼續放寬限制，重新對狀態空間進行DFS。如此反覆直到找到一個解。

顯然這個解是最優的解。

確保解字典序最小的辦法是DFS中順次地從A到H中選擇子狀態。

14.2.6   程式

#include <iostream>
using namespace std;
 
int a[25];
int res[1000];
int ans;
int limit;
 
int state[8][7][2] = {
     { {1,23}, {3,1}, {7,3}, {12,7}, {16,12},{21,16}, {23,21} },
     { {2,24}, {4,2}, {9,4}, {13,9}, {18,13},{22,18}, {24,22} },
     { {11,5}, {10,11}, {9,10}, {8,9}, {7,8},{6,7}, {5,6} },
     { {20,14}, {19,20}, {18,19}, {17,18},{16,17}, {15,16}, {14,15} },
     { {24,2}, {22,24}, {18,22}, {13,18},{9,13}, {4,9}, {2,4} },
     { {23,1}, {21,23}, {16,21}, {12,16},{7,12}, {3,7}, {1,3} },
     { {14,20}, {15,14}, {16,15}, {17,16},{18,17}, {19,18}, {20,19} },
     { {5,11}, {6,5}, {7,6}, {8,7}, {9,8},{10,9}, {11,10} }
 
};
 
 
int isSuccess()
{
     int ll =a[7];
     if(a[8]!=ll|| a[9]!=ll || a[12]!=ll || a[13]!=ll ||
         a[16]!=ll || a[17]!=ll || a[18]!=ll)
         return0;
     return ans= ll;
}
 
int getval()
{
     int i;
     int cnt[4];
     memset(cnt,0,sizeof(cnt));
     for(i = 7;i <=9 ;i++)cnt[a[i]]++;
     for(i = 12;i <=13 ;i++)cnt[a[i]]++;
     for(i = 16;i <=18 ;i++)cnt[a[i]]++;
     return8-max(cnt[1],max(cnt[2],cnt[3]));
}
 
int dfs(int t)
{
     inttemp[25];
     if(t==limit)
         returnisSuccess();
     if(t +getval() > limit)return 0;
     for(int i = 0 ; i < 8 ; i++)
     {
         res[t] = i;
         memcpy(temp,a,sizeof(a));
         for(int j = 0 ; j < 7 ; j++)
              a[state[i][j][1]] =temp[state[i][j][0]];
         int ret= dfs(t+1);
         memcpy(a,temp,sizeof(temp));
         if(ret!=0)return ret;
     }
     return 0;
}
 
 
int main()
{
     while(true)
     {
         scanf("%d",&a[1]);
         if(!a[1])
              break;
         for(int i = 2; i <=24; i++)
              scanf("%d",&a[i]);
         if(isSuccess())
         {
              cout<<"No moves needed"<<endl<<a[7]<<endl;
              continue;
         }
         limit = 1;
         while(dfs(0)== 0)limit++;
         for(int i = 0 ; i < limit ;i++)putchar((char)(res[i]+'A'));
         printf("\n%d\n",ans);
     }
     system("pause");
     return 0;
}

[i] 實用演算法的分析與程式設計。吳文虎，王建德。

[ii] The Art of Computer Programming, Volume 3, Sorting and Searching.Donald E. Knuth.