zoukankan html css js c++ java

Eight POJ

八数码问题。用hash（康托展开）判重

bfs(TLE)

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<queue>
  4 #include<cstring>
  5 using namespace std;
  6 int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
  7 bool hash_map[400000];
  8 int data[400000][12];
  9 queue<int> q;
 10 //data[][9]存储上一个状态，data[][10]存储到这个状态的操作,data[][11]存储这个状态中9的位置
 11 char s[110];
 12 int mem;
 13 int hash1(int s[])
 14 {
 15     int i,j,cnt,sum=0;
 16     for(i=0;i<9;i++)
 17     {
 18         cnt=0;
 19         for(j=i+1;j<9;j++)
 20             if(s[j]<s[i])
 21                 cnt++;
 22         sum+=cnt*fac[8-i];
 23     }
 24     return sum;
 25 }
 26 void print(int x)
 27 {
 28     if(data[x][9]==0)    return;
 29     print(data[x][9]);
 30     if(data[x][10]==1)
 31         putchar('l');
 32     else if(data[x][10]==2)
 33         putchar('r');
 34     else if(data[x][10]==3)
 35         putchar('u');
 36     else putchar('d');
 37 }
 38 int main()
 39 {
 40     char ch;
 41     int i,j,a,b,t,p;
 42     while(cin.getline(s,100))
 43     {
 44         memset(data,0,sizeof(data));
 45         memset(hash_map,0,sizeof(hash_map));
 46         b=mem=1;
 47         j=0;
 48         for(i=0;s[i]!='';i++)
 49         {
 50             if(s[i]==' ')    continue;
 51             sscanf(s+i,"%c",&ch);
 52             if(ch=='x')
 53             {
 54                 data[b][j]=9;
 55                 data[b][11]=j++;
 56             }
 57             else
 58                 data[b][j++]=ch-'0';
 59         }
 60         q.push(b);
 61         t=hash1(data[b]);
 62         hash_map[t]=true;
 63         if(t==0)
 64             goto xxx;
 65         while(!q.empty())
 66         {
 67             a=q.front();
 68             q.pop();
 69             p=data[a][11];
 70             if(p!=0&&p!=3&&p!=6)
 71             {
 72                 memcpy(data[0],data[a],sizeof(data[0]));
 73                 t=data[0][p];
 74                 data[0][p]=data[0][p-1];
 75                 data[0][p-1]=t;
 76                 data[0][9]=a;
 77                 data[0][10]=1;
 78                 data[0][11]=p-1;
 79                 t=hash1(data[0]);
 80                 if(hash_map[t]==false)
 81                 {
 82                     if(t==0)
 83                     {
 84                         print(0);
 85                         goto xxx;
 86                     }
 87                     hash_map[t]=true;
 88                     b=++mem;
 89                     memcpy(data[b],data[0],sizeof(data[b]));
 90                     q.push(b);
 91                 }
 92             }
 93             if(p!=2&&p!=5&&p!=8)
 94             {
 95                 memcpy(data[0],data[a],sizeof(data[0]));
 96                 t=data[0][p];
 97                 data[0][p]=data[0][p+1];
 98                 data[0][p+1]=t;
 99                 data[0][9]=a;
100                 data[0][10]=2;
101                 data[0][11]=p+1;
102                 t=hash1(data[0]);
103                 if(hash_map[t]==false)
104                 {
105                     if(t==0)
106                     {
107                         print(0);
108                         goto xxx;
109                     }
110                     hash_map[t]=true;
111                     b=++mem;
112                     memcpy(data[b],data[0],sizeof(data[b]));
113                     q.push(b);
114                 }
115             }
116             if(p>2)
117             {
118                 memcpy(data[0],data[a],sizeof(data[0]));
119                 t=data[0][p];
120                 data[0][p]=data[0][p-3];
121                 data[0][p-3]=t;
122                 data[0][9]=a;
123                 data[0][10]=3;
124                 data[0][11]=p-3;
125                 t=hash1(data[0]);
126                 if(hash_map[t]==false)
127                 {
128                     if(t==0)
129                     {
130                         print(0);
131                         goto xxx;
132                     }
133                     hash_map[t]=true;
134                     b=++mem;
135                     memcpy(data[b],data[0],sizeof(data[b]));
136                     q.push(b);
137                 }
138             }
139             if(p<6)
140             {
141                 memcpy(data[0],data[a],sizeof(data[0]));
142                 t=data[0][p];
143                 data[0][p]=data[0][p+3];
144                 data[0][p+3]=t;
145                 data[0][9]=a;
146                 data[0][10]=4;
147                 data[0][11]=p+3;
148                 t=hash1(data[0]);
149                 if(hash_map[t]==false)
150                 {
151                     if(t==0)
152                     {
153                         print(0);
154                         goto xxx;
155                     }
156                     hash_map[t]=true;
157                     b=++mem;
158                     memcpy(data[b],data[0],sizeof(data[b]));
159                     q.push(b);
160                 }
161             }
162         }
163         printf("unsolvable");
164         xxx:
165             puts("");
166         while(!q.empty())    q.pop();
167         memset(s,0,sizeof(s));
168     }
169     return 0;
170 }

从目标状态出发，一次bfs打出所有输入对应结果的表(172ms)

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<queue>
  4 #include<cstring>
  5 using namespace std;
  6 int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
  7 bool hash_map[400000];
  8 int data[400000][12];
  9 int temp[12];
 10 queue<int> q;
 11 //data[][9]存储上一个状态，data[][10]存储到这个状态的操作,data[][11]存储这个状态中9的位置
 12 char s[110];
 13 int mem;
 14 int hash1(int s[])
 15 {
 16     int i,j,cnt,sum=0;
 17     for(i=0;i<9;i++)
 18     {
 19         cnt=0;
 20         for(j=i+1;j<9;j++)
 21             if(s[j]<s[i])
 22                 cnt++;
 23         sum+=cnt*fac[8-i];
 24     }
 25     return sum;
 26 }
 27 void print(int x)
 28 {
 29     if(x==1)
 30         putchar('r');
 31     else if(x==2)
 32         putchar('l');
 33     else if(x==3)
 34         putchar('d');
 35     else putchar('u');
 36 }
 37 void init()
 38 {
 39     int i,a,b,p,t;
 40     q.push(0);
 41     for(i=0;i<9;i++)
 42         data[0][i]=i+1;
 43     data[0][11]=8;
 44     hash_map[0]=1;
 45     while(!q.empty())
 46     {
 47         a=q.front();
 48         q.pop();
 49         p=data[a][11];
 50         if(p%3!=0)
 51         {
 52             memcpy(temp,data[a],sizeof(temp));
 53             t=temp[p];
 54             temp[p]=temp[p-1];
 55             temp[p-1]=t;
 56             temp[9]=a;
 57             temp[10]=1;
 58             temp[11]=p-1;
 59             t=hash1(temp);
 60             if(!hash_map[t])
 61             {
 62                 hash_map[t]=1;
 63                 memcpy(data[t],temp,sizeof(data[t]));
 64                 q.push(t);
 65             }
 66         }
 67         if(p%3!=2)
 68         {
 69             memcpy(temp,data[a],sizeof(temp));
 70             t=temp[p];
 71             temp[p]=temp[p+1];
 72             temp[p+1]=t;
 73             temp[9]=a;
 74             temp[10]=2;
 75             temp[11]=p+1;
 76             t=hash1(temp);
 77             if(!hash_map[t])
 78             {
 79                 hash_map[t]=1;
 80                 memcpy(data[t],temp,sizeof(data[t]));
 81                 q.push(t);
 82             }
 83         }
 84         if(p>2)
 85         {
 86             memcpy(temp,data[a],sizeof(temp));
 87             t=temp[p];
 88             temp[p]=temp[p-3];
 89             temp[p-3]=t;
 90             temp[9]=a;
 91             temp[10]=3;
 92             temp[11]=p-3;
 93             t=hash1(temp);
 94             if(!hash_map[t])
 95             {
 96                 hash_map[t]=1;
 97                 memcpy(data[t],temp,sizeof(data[t]));
 98                 q.push(t);
 99             }
100         }
101         if(p<6)
102         {
103             memcpy(temp,data[a],sizeof(temp));
104             t=temp[p];
105             temp[p]=temp[p+3];
106             temp[p+3]=t;
107             temp[9]=a;
108             temp[10]=4;
109             temp[11]=p+3;
110             t=hash1(temp);
111             if(!hash_map[t])
112             {
113                 hash_map[t]=1;
114                 memcpy(data[t],temp,sizeof(data[t]));
115                 q.push(t);
116             }
117         }
118     }
119 }
120 int main()
121 {
122     char ch;
123     int i,j,t,p;
124     init();
125     while(cin.getline(s,100))
126     {
127         j=0;
128         for(i=0;s[i]!='';i++)
129         {
130             if(s[i]==' ')    continue;
131             sscanf(s+i,"%c",&ch);
132             if(ch=='x')
133             {
134                 temp[j]=9;
135                 temp[11]=j++;
136             }
137             else
138                 temp[j++]=ch-'0';
139         }
140         t=hash1(temp);
141         if(!hash_map[t])
142             puts("unsolvable");
143         else
144         {
145             for(i=t;i!=0;i=data[i][9])
146                 print(data[i][10]);
147             puts("");
148         }
149     }
150     return 0;
151 }

以下的IDA*和A*都要用逆序数特判无解的情况，因为无解的时候IDA*直接无限制搜，A*遍历所有解空间，效率很低。

所谓逆序数判无解态是因为两个能够互相移动成的状态的逆序数的奇偶性是相同的。

IDA*(266ms)，估价函数是“所有不为x的方块与目标位置的曼哈顿距离之和”，因为每次移动最多减少一点这个的值

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<queue>
  4 #include<cstring>
  5 using namespace std;
  6 typedef pair<int,int> P;
  7 int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
  8 int dat[13];
  9 char s[110];
 10 char ans[110];
 11 int maxd;
 12 int fx[]={0,0,0,0,1,1,1,2,2,2};
 13 int fy[]={0,0,1,2,0,1,2,0,1,2};
 14 bool fl;
 15 int abs(int x)
 16 {
 17     if(x>0)    return x;
 18     else return -x;
 19 }
 20 int h()
 21 {
 22     int ans=0,i;
 23     for(i=0;i<9;i++)
 24         if(dat[i]!=9)
 25             ans+=abs(i/3-fx[dat[i]])+abs(i%3-fy[dat[i]]);
 26     return ans;
 27 }
 28 int hash1(int s[])
 29 {
 30     int i,j,cnt,sum=0;
 31     for(i=0;i<9;i++)
 32     {
 33         cnt=0;
 34         for(j=i+1;j<9;j++)
 35             if(s[j]<s[i])
 36                 cnt++;
 37         sum+=cnt*fac[8-i];
 38     }
 39     return sum;
 40 }
 41 bool inverse(int ss[])  
 42 {  
 43     int t=0,x,y;
 44     for(int i=1;i<9;i++)  
 45         for(int j=0;j<i;j++)  
 46         {  
 47             if(ss[i]==9||ss[j]==9)continue;  
 48             x=ss[j];  
 49             y=ss[i];  
 50             if(x>y)  
 51                 t++;  
 52         }  
 53     if(t&1)  
 54         return true;  
 55     return false;  
 56 }  
 57 bool check()
 58 {
 59     for(int i=0;i<9;i++)
 60         if(dat[i]!=i+1)
 61             return 0;
 62     return 1;
 63 }
 64 void dfs(int now,int dep)
 65 {
 66     if(dep==maxd)
 67     {
 68         if(check())    fl=1;
 69         return;
 70     }
 71     if(h()+dep>maxd)    return;
 72     if(fl)    return;
 73     if(now%3!=0)
 74     {
 75         swap(dat[now],dat[now-1]);
 76         ans[dep]='l';
 77         dfs(now-1,dep+1);
 78         swap(dat[now],dat[now-1]);
 79     }
 80     if(fl)    return;
 81     if(now%3!=2)
 82     {
 83         swap(dat[now],dat[now+1]);
 84         ans[dep]='r';
 85         dfs(now+1,dep+1);
 86         swap(dat[now],dat[now+1]);
 87     }
 88     if(fl)    return;
 89     if(now>2)
 90     {
 91         swap(dat[now],dat[now-3]);
 92         ans[dep]='u';
 93         dfs(now-3,dep+1);
 94         swap(dat[now],dat[now-3]);
 95     }
 96     if(fl)    return;
 97     if(now<6)
 98     {
 99         swap(dat[now],dat[now+3]);
100         ans[dep]='d';
101         dfs(now+3,dep+1);
102         swap(dat[now],dat[now+3]);
103     }
104 }
105 int main()
106 {
107     char ch;
108     int i,j,st;
109     while(cin.getline(s,100))
110     {
111         memset(dat,0,sizeof(dat));
112         j=0;
113         for(i=0;s[i]!='';i++)
114         {
115             if(s[i]==' ')    continue;
116             sscanf(s+i,"%c",&ch);
117             if(ch=='x')
118             {
119                 dat[j]=9;
120                 st=j++;
121             }
122             else
123                 dat[j++]=ch-'0';
124         }
125         if(inverse(dat))
126         {
127             printf("unsolvable");
128             goto xxx;
129         }
130         if(hash1(dat)==0)
131             goto xxx;
132         fl=0;
133         for(maxd=1;!fl;++maxd)
134         dfs(st,0);
135         for(i=0;i<maxd;i++)
136             putchar(ans[i]);
137         xxx:
138             puts("");
139     }
140     return 0;
141 }

A*(141ms)，用了比较naive的估价函数，x与目标位置的曼哈顿距离

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<queue>
  4 #include<cstring>
  5 using namespace std;
  6 typedef pair<int,int> P;
  7 int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
  8 bool hash_map[400000];
  9 int dat[400000][13];
 10 priority_queue<P,vector<P>,greater<P> > q;
 11 //dat[][9]存储上一个状态，dat[][10]存储到这个状态的操作,dat[][11]存储这个状态中9的位置,dat[][12]存储到这个状态的步数
 12 char s[110];
 13 int h[]={4,3,2,3,2,1,2,1,0};
 14 int mem;
 15 int hash1(int s[])
 16 {
 17     int i,j,cnt,sum=0;
 18     for(i=0;i<9;i++)
 19     {
 20         cnt=0;
 21         for(j=i+1;j<9;j++)
 22             if(s[j]<s[i])
 23                 cnt++;
 24         sum+=cnt*fac[8-i];
 25     }
 26     return sum;
 27 }
 28 void print(int x)
 29 {
 30     if(dat[x][9]==0)    return;
 31     print(dat[x][9]);
 32     if(dat[x][10]==1)
 33         putchar('l');
 34     else if(dat[x][10]==2)
 35         putchar('r');
 36     else if(dat[x][10]==3)
 37         putchar('u');
 38     else putchar('d');
 39 }
 40 
 41 bool inverse(int ss[])  
 42 {  
 43     int t=0,x,y;
 44     for(int i=1;i<9;i++)  
 45         for(int j=0;j<i;j++)  
 46         {  
 47             if(ss[i]==9||ss[j]==9)continue;  
 48             x=ss[j];  
 49             y=ss[i];  
 50             if(x>y)  
 51                 t++;  
 52         }  
 53     if(t&1)  
 54         return true;  
 55     return false;  
 56 }  
 57 
 58 
 59 int main()
 60 {
 61     char ch;
 62     int i,j,a,b,t,p;
 63     while(cin.getline(s,100))
 64     {
 65         memset(dat,0,sizeof(dat));
 66         memset(hash_map,0,sizeof(hash_map));
 67         b=mem=1;
 68         j=0;
 69         for(i=0;s[i]!='';i++)
 70         {
 71             if(s[i]==' ')    continue;
 72             sscanf(s+i,"%c",&ch);
 73             if(ch=='x')
 74             {
 75                 dat[b][j]=9;
 76                 dat[b][11]=j++;
 77             }
 78             else
 79                 dat[b][j++]=ch-'0';
 80         }
 81         q.push(P(h[dat[b][11]],b));
 82         t=hash1(dat[b]);
 83         hash_map[t]=true;
 84         if(inverse(dat[b]))
 85         {
 86             printf("unsolvable");
 87             goto xxx;
 88         }
 89         if(t==0)
 90             goto xxx;
 91         while(!q.empty())
 92         {
 93             a=q.top().second;
 94             q.pop();
 95             p=dat[a][11];
 96             if(p!=0&&p!=3&&p!=6)
 97             {
 98                 memcpy(dat[0],dat[a],sizeof(dat[0]));
 99                 t=dat[0][p];
100                 dat[0][p]=dat[0][p-1];
101                 dat[0][p-1]=t;
102                 dat[0][9]=a;
103                 dat[0][10]=1;
104                 dat[0][11]=p-1;
105                 dat[0][12]=dat[p][12]+1;
106                 t=hash1(dat[0]);
107                 if(hash_map[t]==false)
108                 {
109                     if(t==0)
110                     {
111                         print(0);
112                         goto xxx;
113                     }
114                     hash_map[t]=true;
115                     b=++mem;
116                     memcpy(dat[b],dat[0],sizeof(dat[b]));
117                     q.push(P(dat[b][12]+h[dat[b][11]],b));
118                 }
119             }
120             if(p!=2&&p!=5&&p!=8)
121             {
122                 memcpy(dat[0],dat[a],sizeof(dat[0]));
123                 t=dat[0][p];
124                 dat[0][p]=dat[0][p+1];
125                 dat[0][p+1]=t;
126                 dat[0][9]=a;
127                 dat[0][10]=2;
128                 dat[0][11]=p+1;
129                 dat[0][12]=dat[p][12]+1;
130                 t=hash1(dat[0]);
131                 if(hash_map[t]==false)
132                 {
133                     if(t==0)
134                     {
135                         print(0);
136                         goto xxx;
137                     }
138                     hash_map[t]=true;
139                     b=++mem;
140                     memcpy(dat[b],dat[0],sizeof(dat[b]));
141                     q.push(P(dat[b][12]+h[dat[b][11]],b));
142                 }
143             }
144             if(p>2)
145             {
146                 memcpy(dat[0],dat[a],sizeof(dat[0]));
147                 t=dat[0][p];
148                 dat[0][p]=dat[0][p-3];
149                 dat[0][p-3]=t;
150                 dat[0][9]=a;
151                 dat[0][10]=3;
152                 dat[0][11]=p-3;
153                 dat[0][12]=dat[p][12]+1;
154                 t=hash1(dat[0]);
155                 if(hash_map[t]==false)
156                 {
157                     if(t==0)
158                     {
159                         print(0);
160                         goto xxx;
161                     }
162                     hash_map[t]=true;
163                     b=++mem;
164                     memcpy(dat[b],dat[0],sizeof(dat[b]));
165                     q.push(P(dat[b][12]+h[dat[b][11]],b));
166                 }
167             }
168             if(p<6)
169             {
170                 memcpy(dat[0],dat[a],sizeof(dat[0]));
171                 t=dat[0][p];
172                 dat[0][p]=dat[0][p+3];
173                 dat[0][p+3]=t;
174                 dat[0][9]=a;
175                 dat[0][10]=4;
176                 dat[0][11]=p+3;
177                 dat[0][12]=dat[p][12]+1;
178                 t=hash1(dat[0]);
179                 if(hash_map[t]==false)
180                 {
181                     if(t==0)
182                     {
183                         print(0);
184                         goto xxx;
185                     }
186                     hash_map[t]=true;
187                     b=++mem;
188                     memcpy(dat[b],dat[0],sizeof(dat[b]));
189                     q.push(P(dat[b][12]+h[dat[b][11]],b));
190                 }
191             }
192         }
193         xxx:
194             puts("");
195         while(!q.empty())    q.pop();
196         memset(s,0,sizeof(s));
197     }
198     return 0;
199 }

A*(16ms)，估价函数同IDA*

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<queue>
  4 #include<cstring>
  5 using namespace std;
  6 typedef pair<int,int> P;
  7 int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
  8 bool hash_map[400000];
  9 int dat[400000][13];
 10 priority_queue<P,vector<P>,greater<P> > q;
 11 //dat[][9]存储上一个状态，dat[][10]存储到这个状态的操作,dat[][11]存储这个状态中9的位置,dat[][12]存储到这个状态的步数
 12 char s[110];
 13 int fx[]={0,0,0,0,1,1,1,2,2,2};
 14 int fy[]={0,0,1,2,0,1,2,0,1,2};
 15 int abs(int x)
 16 {
 17     if(x>0)    return x;
 18     else return -x;
 19 }
 20 int h(int b)
 21 {
 22     int ans=0,i;
 23     for(i=0;i<9;i++)
 24         if(dat[b][i]!=9)
 25             ans+=abs(i/3-fx[dat[b][i]])+abs(i%3-fy[dat[b][i]]);
 26     return ans;
 27 }
 28 int mem;
 29 int hash1(int s[])
 30 {
 31     int i,j,cnt,sum=0;
 32     for(i=0;i<9;i++)
 33     {
 34         cnt=0;
 35         for(j=i+1;j<9;j++)
 36             if(s[j]<s[i])
 37                 cnt++;
 38         sum+=cnt*fac[8-i];
 39     }
 40     return sum;
 41 }
 42 void print(int x)
 43 {
 44     if(dat[x][9]==0)    return;
 45     print(dat[x][9]);
 46     if(dat[x][10]==1)
 47         putchar('l');
 48     else if(dat[x][10]==2)
 49         putchar('r');
 50     else if(dat[x][10]==3)
 51         putchar('u');
 52     else putchar('d');
 53 }
 54 
 55 bool inverse(int ss[])  
 56 {  
 57     int t=0,x,y;
 58     for(int i=1;i<9;i++)  
 59         for(int j=0;j<i;j++)  
 60         {  
 61             if(ss[i]==9||ss[j]==9)continue;  
 62             x=ss[j];  
 63             y=ss[i];  
 64             if(x>y)  
 65                 t++;  
 66         }  
 67     if(t&1)  
 68         return true;  
 69     return false;  
 70 }  
 71 
 72 
 73 int main()
 74 {
 75     char ch;
 76     int i,j,a,b,t,p;
 77     while(cin.getline(s,100))
 78     {
 79         memset(dat,0,sizeof(dat));
 80         memset(hash_map,0,sizeof(hash_map));
 81         b=mem=1;
 82         j=0;
 83         for(i=0;s[i]!='';i++)
 84         {
 85             if(s[i]==' ')    continue;
 86             sscanf(s+i,"%c",&ch);
 87             if(ch=='x')
 88             {
 89                 dat[b][j]=9;
 90                 dat[b][11]=j++;
 91             }
 92             else
 93                 dat[b][j++]=ch-'0';
 94         }
 95         q.push(P(h(b),b));
 96         t=hash1(dat[b]);
 97         hash_map[t]=true;
 98         if(inverse(dat[b]))
 99         {
100             printf("unsolvable");
101             goto xxx;
102         }
103         if(t==0)
104             goto xxx;
105         while(!q.empty())
106         {
107             a=q.top().second;
108             q.pop();
109             p=dat[a][11];
110             if(p!=0&&p!=3&&p!=6)
111             {
112                 memcpy(dat[0],dat[a],sizeof(dat[0]));
113                 t=dat[0][p];
114                 dat[0][p]=dat[0][p-1];
115                 dat[0][p-1]=t;
116                 dat[0][9]=a;
117                 dat[0][10]=1;
118                 dat[0][11]=p-1;
119                 dat[0][12]=dat[p][12]+1;
120                 t=hash1(dat[0]);
121                 if(hash_map[t]==false)
122                 {
123                     if(t==0)
124                     {
125                         print(0);
126                         goto xxx;
127                     }
128                     hash_map[t]=true;
129                     b=++mem;
130                     memcpy(dat[b],dat[0],sizeof(dat[b]));
131                     q.push(P(dat[b][12]+h(b),b));
132                 }
133             }
134             if(p!=2&&p!=5&&p!=8)
135             {
136                 memcpy(dat[0],dat[a],sizeof(dat[0]));
137                 t=dat[0][p];
138                 dat[0][p]=dat[0][p+1];
139                 dat[0][p+1]=t;
140                 dat[0][9]=a;
141                 dat[0][10]=2;
142                 dat[0][11]=p+1;
143                 dat[0][12]=dat[p][12]+1;
144                 t=hash1(dat[0]);
145                 if(hash_map[t]==false)
146                 {
147                     if(t==0)
148                     {
149                         print(0);
150                         goto xxx;
151                     }
152                     hash_map[t]=true;
153                     b=++mem;
154                     memcpy(dat[b],dat[0],sizeof(dat[b]));
155                     q.push(P(dat[b][12]+h(b),b));
156                 }
157             }
158             if(p>2)
159             {
160                 memcpy(dat[0],dat[a],sizeof(dat[0]));
161                 t=dat[0][p];
162                 dat[0][p]=dat[0][p-3];
163                 dat[0][p-3]=t;
164                 dat[0][9]=a;
165                 dat[0][10]=3;
166                 dat[0][11]=p-3;
167                 dat[0][12]=dat[p][12]+1;
168                 t=hash1(dat[0]);
169                 if(hash_map[t]==false)
170                 {
171                     if(t==0)
172                     {
173                         print(0);
174                         goto xxx;
175                     }
176                     hash_map[t]=true;
177                     b=++mem;
178                     memcpy(dat[b],dat[0],sizeof(dat[b]));
179                     q.push(P(dat[b][12]+h(b),b));
180                 }
181             }
182             if(p<6)
183             {
184                 memcpy(dat[0],dat[a],sizeof(dat[0]));
185                 t=dat[0][p];
186                 dat[0][p]=dat[0][p+3];
187                 dat[0][p+3]=t;
188                 dat[0][9]=a;
189                 dat[0][10]=4;
190                 dat[0][11]=p+3;
191                 dat[0][12]=dat[p][12]+1;
192                 t=hash1(dat[0]);
193                 if(hash_map[t]==false)
194                 {
195                     if(t==0)
196                     {
197                         print(0);
198                         goto xxx;
199                     }
200                     hash_map[t]=true;
201                     b=++mem;
202                     memcpy(dat[b],dat[0],sizeof(dat[b]));
203                     q.push(P(dat[b][12]+h(b),b));
204                 }
205             }
206         }
207         xxx:
208             puts("");
209         while(!q.empty())    q.pop();
210         memset(s,0,sizeof(s));
211     }
212     return 0;
213 }

A*(79ms)，假的估价函数(fx,fy前面少加了一个0)

int fx[]={0,0,0,1,1,1,2,2,2};
int fy[]={0,1,2,0,1,2,0,1,2};

查看全文

相关阅读:
Socket和数据库的一些使用---郭雪彬
 懒加载--初步理解. by:王朋
 自定义带图片和文字的Button的排版--陈棚
 一些开源库分享－－－严焕培
 实现“手机qq”侧滑菜单 -- 吴欧
 iOS 小技巧总结
 Responder一点也不神秘————iOS用户响应者链完全剖析周傅琦君
 通过版本号来判断用户是否是第一次登陆----By张秀清
 常用第三方推荐
 static, const 和 static const 变量的初始化问题

原文地址：https://www.cnblogs.com/hehe54321/p/7804986.html