POJ1077 Eight —— IDA*算法

主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html

代码一：像BFS那样，把棋盘数组放在结构体中。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 #define ms(a,b) memset((a),(b),sizeof((a)))
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int MOD = 1e9+;
 const int MAXN = 1e6+;
 #define AIM  1     //123456789的哈希值为1

 struct node
 {
     int s[];
     int loc;
 };

 int fac[] = { , , , , , , , , };
 int dir[][] = { -,, ,, ,-, , };
 char op[] = {'u', 'd', 'l', 'r'  };

 int cantor(int s[])  //获得哈希函数值
 {
     int sum = ;
     for(int i = ; i<; i++)
     {
         int num = ;
         for(int j = i+; j<; j++)
             if(s[j]<s[i]) num++;
         sum += num*fac[-i];
     }
     return sum+;
 }

 int dis_h(int s[])  //获得曼哈顿距离
 {
     int dis = ;
     for(int i = ; i<; i++)
     if(s[i]!=)
     {
         int x = i/, y = i%;
         int xx = (s[i]-)/, yy = (s[i]-)%;
         dis += abs(x-xx) + abs(y-yy);
     }
     return dis;
 }

 char path[];
 bool IDAstar(node now, int depth, int pre, int limit)
 {
     if(dis_h(now.s)==)     //搜到123456789
     {
         path[depth] = '\0';
         puts(path);
         return true;
     }

     int x = now.loc/;
     int y = now.loc%;
     for(int i = ; i<; i++)
     {
         if(i+pre== || i+pre==) continue;  //方向与上一步相反， 剪枝
         int xx = x + dir[i][];
         int yy = y + dir[i][];
         if(xx>= && xx<= && yy>= && yy<=)
         {
             node tmp = now;
             tmp.s[x*+y] = tmp.s[xx*+yy];
             tmp.s[xx*+yy] = ;
             tmp.loc = xx*+yy;
             path[depth] = op[i];
             if(depth++dis_h(tmp.s)<=limit)     //在限制内
                 if(IDAstar(tmp, depth+, i, limit))
                     return true;
         }
     }
     return false;
 }

 int main()
 {
     char str[];
     while(gets(str))
     {
         node now;
         int cnt = ;
         for(int i = ; str[i]; i++)
         {
             if(str[i]==' ') continue;
             if(str[i]=='x') now.s[cnt] = , now.loc = cnt++;
             else  now.s[cnt++] = str[i]-'';
         }

         int limit;
         for(limit = ; limit<=; limit++)     //迭代加深搜
             if(IDAstar(now, , INF, limit))
                 break;
         if(limit>)
             puts("unsolvable");
     }
 }

代码二：根据DFS的特点，由于棋盘每次只交换一对，所以可以只开一个棋盘数组。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 #define ms(a,b) memset((a),(b),sizeof((a)))
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int MOD = 1e9+;
 const int MAXN = 1e6+;

 int M[];
 int fac[] = { , , , , , , , , };
 int dir[][] = { -,, ,, ,-, , };
 char op[] = {'u', 'd', 'l', 'r'  };

 int cantor(int s[])  //获得哈希函数值
 {
     int sum = ;
     for(int i = ; i<; i++)
     {
         int num = ;
         for(int j = i+; j<; j++)
             if(s[j]<s[i]) num++;
         sum += num*fac[-i];
     }
     return sum+;
 }

 int dis_h(int s[])  //获得曼哈顿距离
 {
     int dis = ;
     for(int i = ; i<; i++)
     if(s[i]!=)
     {
         int x = i/, y = i%;
         int xx = (s[i]-)/, yy = (s[i]-)%;
         dis += abs(x-xx) + abs(y-yy);
     }
     return dis;
 }

 char path[];
 bool IDAstar(int loc, int depth, int pre, int limit)
 {
     int h = dis_h(M);
     if(depth+h>limit)
         return false;

     if(h==)     //搜到123456789
     {
         path[depth] = '\0';
         puts(path);
         return true;
     }

     int x = loc/;
     int y = loc%;
     for(int i = ; i<; i++)
     {
         if(i+pre== || i+pre==) continue;  //方向与上一步相反， 剪枝
         int xx = x + dir[i][];
         int yy = y + dir[i][];
         if(xx>= && xx<= && yy>= && yy<=)
         {
             swap(M[loc], M[xx*+yy]);
             path[depth] = op[i];
             if(IDAstar(xx*+yy, depth+, i, limit))
                 return true;
             swap(M[loc], M[xx*+yy]);
         }
     }
     return false;
 }

 int main()
 {
     char str[];
     while(gets(str))
     {
         int cnt = , loc;
         for(int i = ; str[i]; i++)
         {
             if(str[i]==' ') continue;
             if(str[i]=='x') M[cnt] = , loc = cnt++;
             else  M[cnt++] = str[i]-'';
         }

         int limit;
         for(limit = ; limit<=; limit++)     //迭代加深搜
             if(IDAstar(loc, , INF, limit))
                 break;
         if(limit>)
             puts("unsolvable");
     }
 }