今天學習了IDA*演算法，在這裡總結一下：

IDA*演算法是A*演算法和迭代加深演算法的結合。

迭代加深演算法是在dfs搜尋演算法的基礎上逐步加深搜尋的深度，它避免了廣度優先搜尋佔用搜尋空間太大的缺點，也減少了深度優先搜尋的盲目性。它主要是在遞迴搜尋函式的開頭判斷當前搜尋的深度是否大於預定義的最大搜索深度，如果大於，就退出這一層的搜尋，如果不大於，就繼續進行搜尋。這樣最終獲得的解必然是最優解。

而在A*演算法中，我們通過使用合理的估價函式，然後在獲得的子節點中選擇fCost最小的節點進行擴充套件，以此完成搜尋最優解的目的。但是A*演算法中，需要維護關閉列表和開放列表，需要對擴展出來的節點進行檢測，忽略已經進入到關閉列表中的節點（也就是所謂的“已經檢測過的節點”），另外也要檢測是否與待擴充套件的節點重複，如果重複進行相應的更新操作。所以A*演算法主要的代價花在了狀態檢測和選擇代價最小節點的排序上，這個過程中佔用的記憶體是比較大的，一般為了提高效率都是使用hash進行重複狀態檢測。

而IDA*演算法具有如下的特點：（

綜合了A*演算法的人工智慧性和回溯法對空間的消耗較少的優點，在一些規模很大的搜尋問題中會起意想不到的效果。它的具體名稱是 Iterative Deepening A*, 1985年由Korf提出。該演算法的最初目的是為了利用深度搜索的優勢解決廣度A*的空間問題，其代價是會產生重複搜尋。歸納一下，IDA*的基本思路是：首先將初始狀態結點的H值設為閾值maxH，然後進行深度優先搜尋，搜尋過程中忽略所有H值大於maxH的結點；如果沒有找到解，則加大閾值maxH，再重複上述搜尋，直到找到一個解。在保證H值的計算滿足A*演算法的要求下，可以證明找到的這個解一定是最優解。在程式實現上，IDA* 要比 A* 方便，因為不需要儲存結點，不需要判重複，也不需要根據 H值對結點排序，佔用空間小

在一般的問題中是這樣使用IDA*演算法的，當前局面的估價函式值+當前的搜尋深度 > 預定義的最大搜索深度時，就進行剪枝。

這個估計函式的選取沒有統一的標準，找到合適的該函式並不容易，但是可以大致按照這個原則：在一定範圍內加大各個狀態啟發函式值的差別。

下面是poj2286 the rotation game的一道題目，使用了IDA*演算法：

 #include <iostream> #include <string> using namespace std; //a:記錄數字的陣列 int a[25], cnt[25]; char out[1000]; int deep; //最後的局面中心的結果數字 int res; //判斷是否到達目標狀態 bool ok(int *a) { int tmp=a[7]; if( tmp!=a[8] || tmp!=a[9] || tmp!=a[12] || tmp!=a[13] || tmp!=a[16] || tmp!=a[17] || tmp!=a[18] ) return false; return true; } //旋轉 inline void change(int* cur,int a,int b,int c,int d,int e,int f,int g) { int tmp=cur[a]; cur[a]=cur[b],cur[b]=cur[c],cur[c]=cur[d],cur[d]=cur[e],cur[e]=cur[f],cur[f]=cur[g],cur[g]=tmp; } //計算8個標準位置中數量最多的數字有多少個 inline int count(int* a) { memset(cnt,0,sizeof(cnt)); cnt[a[7]]++;cnt[a[8]]++;cnt[a[9]]++; cnt[a[12]]++;cnt[a[13]]++;cnt[a[16]]++; cnt[a[17]]++;cnt[a[18]]++; cnt[2]=cnt[1]>cnt[2]?cnt[1]:cnt[2]; return max(cnt[2],cnt[3]); } //pre：上一次遞迴移動的方向 //now:當前遞迴的步數 bool dfs(int *a, int now, int pre) { //剪枝：如果當前可以遞迴的深度已經小於局面中心數字所需量 if (deep - now < 8 - count(a)) return false; //超過當前的搜尋深度 if (now >= deep) return false; int temp[25]; //備份當前的局面 for (int i = 0; i < 8; ++i) { //如果前後兩次拉動的方向恰好相反，那麼就剪枝 if( (pre==0 && i==5) || (pre==5 && i==0) ) continue; if( (pre==1 && i==4) || (pre==4 && i==1) ) continue; if( (pre==2 && i==7) || (pre==7 && i==2) ) continue; if( (pre==3 && i==6) || (pre==6 && i==3) ) continue; for (int j = 1; j <= 24; ++j) { temp[j] = a[j]; } switch(i) { case 0:out[now]='A';change(temp,1,3,7,12,16,21,23);break; case 1:out[now]='B';change(temp,2,4,9,13,18,22,24);break; case 2:out[now]='C';change(temp,11,10,9,8,7,6,5);break; case 3:out[now]='D';change(temp,20,19,18,17,16,15,14);break; case 4:out[now]='E';change(temp,24,22,18,13,9,4,2);break; case 5:out[now]='F';change(temp,23,21,16,12,7,3,1);break; case 6:out[now]='G';change(temp,14,15,16,17,18,19,20);break; case 7:out[now]='H';change(temp,5,6,7,8,9,10,11);break; } if (ok(temp)) { res = temp[7]; out[now+1] = '/0'; return true; } if (dfs(temp, now + 1, i)) return true; } return false; } int main() { while (scanf("%d", &a[1]) && a[1]) { for (int i = 2; i <= 24; ++i) scanf("%d", a+i); if (ok(a)) { //如果已經符合要求了 printf("No moves needed/n"); printf("%d/n", a[7]); } else { deep = 1; //clock_t time= clock(); while (1) { if (dfs(a, 0, -1)) break; ++deep; } printf("%s/n", out); printf("%d/n", res); } } return 0; }

有空找一下錯誤，發現錯誤的哥們可以給我留個言：（ps:錯誤解決了，在IDA*演算法的遞迴呼叫if語句為true時，應該返回的是true，而不是false）。

/* * POJ2286 The Rotation Game * 解題思路：使用迭代加深的深度搜索演算法，這裡非常要注意還是剪枝的問題 * 只有較好的針對題目環境的剪枝，才能提高搜尋效率 */ #include<iostream> #include<fstream> #include<string> using namespace std; //使用陣列表示遊戲局面 int map[25],countArray[25]; //搜尋深度 , 最終的局面中心數字 int DEPTH,res; char outPath[100]; //判斷是否到達了目標局面 bool isOk(const int* state){ int tmp = state[7]; if( tmp!= state[8] || tmp!=state[9] || tmp!= state[12] || tmp!= state[13] || tmp!=state[16] || tmp!= state[17] || tmp!= state[18] ){ return false ; } return true ; } //統計局面的中心區域含有相同數字的最大數量 int countMaxSameNumber(const int* state){ memset(countArray , 0 ,sizeof(countArray) ) ; countArray[ state[7] ]++; countArray[state[8]] ++; countArray[state[9]]++; countArray[ state[12] ]++; countArray[ state[13] ]++ ; countArray[state[16]]++; countArray[state[17]] ++ ; countArray[state[18]]++; countArray[2] = (countArray[2]>countArray[1]) ? countArray[2]: countArray[1]; return max(countArray[2],countArray[3]); } void changeState(int *state,int a1,int a2,int a3,int a4,int a5,int a6,int a7){ int tmp = state[a1]; state[a1]=state[a2],state[a2]=state[a3],state[a3]=state[a4], state[a4]=state[a5],state[a5]=state[a6],state[a6]=state[a7],state[a7]=tmp; } //迭代加深搜尋 //state：當前局面 currDepth :當前所處的搜尋深度 preDir：當前搜尋選擇的旋轉的方向 bool dfsSearch( int* state ,int currDepth , int preDir) { //剪枝 1 : 本質上使用的就是IDA*估價函式進行剪枝 if( DEPTH - currDepth < 8- countMaxSameNumber(state)) return false ; //超過了當前的搜尋深度 if( DEPTH <= currDepth ) return false ; int tmp[25]; for(int i=1 ; i<=8 ; i++){ //剪枝2 ：前後連續的相反方向的兩次旋轉是沒有意義的 if( (1 == i && 6 == preDir) || (6==i && 1== preDir) ) continue ; if( (2 == i && 5 == preDir) || (5==i && 2== preDir) ) continue ; if( (3 == i && 8 == preDir) || (8==i && 3== preDir) ) continue ; if( (4 == i && 7 == preDir) || (7==i && 4== preDir) ) continue ; // memcpy( tmp , state , sizeof(state)) ; for(int k=1 ; k<=24 ; k++) tmp[k]=state[k]; switch(i){ //記錄搜尋路徑 case 1 : outPath[currDepth] = 'A' ; changeState(tmp,1,3,7,12,16,21,23); break; case 2 : outPath[currDepth] = 'B' ; changeState(tmp,2,4,9,13,18,22,24); break; case 3 : outPath[currDepth] = 'C' ; changeState(tmp,11,10,9,8,7,6,5); break; case 4 : outPath[currDepth] = 'D' ; changeState(tmp,20,19,18,17,16,15,14); break; case 5 : outPath[currDepth] = 'E' ; changeState(tmp,24,22,18,13,9,4,2); break; case 6 : outPath[currDepth] = 'F' ; changeState(tmp,23,21,16,12,7,3,1); break; case 7 : outPath[currDepth] = 'G' ; changeState(tmp,14,15,16,17,18,19,20); break; case 8 : outPath[currDepth] = 'H' ; changeState(tmp,5,6,7,8,9,10,11); break; default : cout<<"ERROR!"<<endl; } if( isOk(tmp) ){ res = tmp[7]; outPath[currDepth +1 ]='/0'; return true ; } if( dfsSearch(tmp , currDepth+1 , i)) return true ; } return false ; } int main(){ ifstream in("test.txt"); while(1){ in>>map[1]; if( 0 == map[1]) break; for(int i=2 ; i<=24 ; i++) in>>map[i]; if( isOk(map)){ cout<<"No moves needed"<<endl; cout<<map[7]<<endl; } else{ DEPTH =1 ; while(1){ if(dfsSearch(map , 0 , -1 )) break; DEPTH ++ ; } cout<<outPath<<endl; cout<<res<<endl; } } }

下面是一道自己做的poj2870的搜尋題，在這道題中，我也使用了IDA*演算法來剪枝，比起純粹的dfs，效果還是很明顯的。

/* * POJ2870 Light Up */ //#include<cstdio> #include<iostream> #include<fstream> #include<ctime> #define MAXSIZE 8 #define MAX_BARRIAR 50 #define NOT ! #define __DEBUG 0 using namespace std; char board[MAXSIZE][MAXSIZE]; int wid,height,barriarNum; //表示搜尋的深度 int depth,minLamp; //記錄有編號的障礙的位置的結構體 typedef struct numedbarriar{ int x; int y; int no; }NumedBarriar; NumedBarriar barriarArray[MAX_BARRIAR] ; static int dir[4][2]={ {0,-1},{-1,0},{0,1},{1,0} }; //列印當前局面 void print(char c[][MAXSIZE]){ for(int i=1 ; i<=height ; i++){ for(int j=1 ; j<=wid ; j++){ cout<<c[i][j]<<" "; } cout<<endl; } cout<<endl<<endl; } inline bool isInBoard(int x,int y){ return ( x<1 || x>height || y<1 || y>wid ) ? false : true ; } //標記被照亮的地方 void change(char map[MAXSIZE][MAXSIZE],int x,int y){ map[x][y]='L'; int m,n ; //往左 for(int j=0 ; j<4 ; j++){ for( m=x+dir[j][0] , n=y+dir[j][1]; isInBoard(m,n) ; m+=dir[j][0], n+=dir[j][1] ){ if( '.'== map[m][n] || 'm' == map[m][n]){ map[m][n]='m'; } else{ break; } } } } //計算有編號的障礙周圍還缺少的Lamp數目 int gCost(char map[][MAXSIZE]){ int num=0 ,x,y , dist =0 ; for(int i=0 ; i<barriarNum ;i++) { if( -1 == barriarArray[i].no ) continue ; num = 0; for(int j=0; j<4 ;j++){ x = barriarArray[i].x + dir[j][0]; y = barriarArray[i].y + dir[j][1]; if( isInBoard(x,y) && 'L' == map[x][y] ){ num ++ ; } } dist += barriarArray[i].no - num ; } return dist ; } inline bool isCompleted(char map[][MAXSIZE]){ for(int i=1 ; i<=height ;i++){ for(int j=1; j<=wid ; j++){ if( '.' == map[i][j]) return false ; } } return (true && 0 == gCost(map)); } //檢查是否超出帶編號barriar規定的周圍最大的lamp數量 bool isAllowed(char map[][MAXSIZE]){ int x,y,num; for(int i=0 ; i<barriarNum ;i++) { if( -1 == barriarArray[i].no ) continue ; //每次檢查前初始化 num = 0; for(int j=0; j<4 ;j++){ x = barriarArray[i].x + dir[j][0]; y = barriarArray[i].y + dir[j][1]; if( isInBoard(x,y) && 'L' == map[x][y] ){ num ++ ; } } if( num > barriarArray[i].no) return false ; } return true ; } bool dfsSearch(char map[MAXSIZE][MAXSIZE],int currDepth) { //IDA*剪枝 if( currDepth + gCost(map) > depth ) return false ; if( currDepth >=minLamp ) return false ; //剪枝1 if(NOT isAllowed(map)){ return false ; } int i,j; char tmpMap[MAXSIZE][MAXSIZE]; for(i=1 ; i<= height ; i++){ for(j=1 ; j<=wid ; j++){ //找到可放置的位置 if( '.' == map[i][j] ){ //memcpy(tmpMap , map , sizeof(map) ); for(int m=1; m<= height ; m++){ for(int n=1 ; n<=wid ; n++){ tmpMap[m][n]= map[m][n]; } } //改變當前的局面，標記當前lamp照亮的位置 change(tmpMap,i,j); if( isCompleted(tmpMap) ) { if( currDepth < minLamp ) minLamp = currDepth+1; // cout<<"find"<<minLamp<<endl; print(tmpMap); return true; } if(dfsSearch( tmpMap , currDepth+1)){ // print(tmpMap); return true ; } //memcpy(map,tmpMap,sizeof(tmpMap)); //for(int m=1; m<= height ; m++){ // // for(int n=1 ; n<=wid ; n++){ // // map[m][n]= tmpMap[m][n]; // } // } } } } return false ; } int main(){ ifstream in("test.txt"); bool findSolution; while(1){ in>>height>>wid ; if( 0==wid && 0== height) break; //初始化局面 for(int i=0 ; i< MAXSIZE ; i++){ for(int j=0 ; j<MAXSIZE ; j++){ board[i][j] = '.'; } } findSolution = true ; minLamp=100; in>>barriarNum; for(int i=0 ; i<barriarNum ; i++){ in>>barriarArray[i].x>>barriarArray[i].y>>barriarArray[i].no; //普通的barriar if( -1 == barriarArray[i].no) board[ barriarArray[i].x ][barriarArray[i].y]='b'; //有編號的barriar else{ board[ barriarArray[i].x ][barriarArray[i].y]=barriarArray[i].no+'0'; } } depth = 0; clock_t time=clock(); while(1){ if( NOT dfsSearch(board , 0)) depth ++; else break; if(depth>100){ cout<<"No solution"<<endl; findSolution = false ; break; } } cout <<"time: "<< clock()-time<<" MS" <<endl; cout<<"Depth: "<<depth<<endl; if(findSolution ) cout<<minLamp<<endl; } }

在這裡我總結一下IDA*搜尋演算法的一些注意點：

1、IDA*演算法中，main函式一般使用逐步加大搜索深度來獲得最優解，而如果使用dfs搜尋策略的話，就需要對整個搜尋空間進行搜尋，在搜尋函式中判斷出所有合法解中的最優解（通過比較合法解的深度，選擇深度最小的，其實在bfs搜尋中，深度對應的就是題目中所要求的最優解量）

2、在IDA*的搜尋核心演算法中，前半部分就是剪枝，返回false的情況，這點和dfs是一樣的。而在常規的搜尋中，當找到最優解時，就返回true，而當後面的if語句中的dfs遞迴為true時，返回true，如此退出整個迴圈，否則會死迴圈。為了提高效率，可以把當前狀態拷貝到臨時狀態，然後使用臨時狀態進行遞迴搜尋，這樣就不需要在遞迴函式返回時，還原原來的整個狀態。

另外可以看到通過下面的程式碼中新增適當的語句就可以還原出整個最優解的路徑：

if( isCompleted(tmpMap) ) { if( currDepth < minLamp ) minLamp = currDepth+1; // cout<<"find"<<minLamp<<endl; print(tmpMap); return true; } if(dfsSearch( tmpMap , currDepth+1)){ // print(tmpMap); return true ; }