神奇搜索算法A*
A*
A*是一种启发式搜索算法，又叫最佳图搜索算法。
何谓启发式搜索？
众所周知，计算机在执行搜索算法时是没开上帝视角的。因此，在搜索时，往往显得盲目，把所有可能的状态全部遍历，这种搜索我们统称盲目搜索。
启发式搜索，顾名思义，其实就是给了盲目的计算机一点启发，一点智慧，利用这些来引导计算机减少搜索范围，大幅降低搜索复杂度。试想在BFS的过程中，在某一阶段某些状态成为正解的概率明显比别的状态要大，那我们就优先选择这些状态继续BFS，达到降低复杂度的目的。那么怎么计算这个概率呢？
我们需要给计算机一些启发信息。不同的启发信息有不同的强度，既不能太强也不能弱，太强会导致得不到正解，而太弱又会导致优化效果不明显。都说了这么多了，那就来点具体的。
如何进行启发式搜索？
在A*之前，首先要提一下A算法，A*是A的一种特殊情形。
这里我们要引入一个函数——“估价函数”。
定义一个函数\(f(n)=g(n)+h(n)\)，利用启发信息计算出\(h\)，根据\(f\)函数的值找出当前搜索状态下的最有希望的节点进行扩展。其中\(n\)是一个状态，\(f\)就是估价函数，\(g\)是\(n\)已经用掉的开销（可以理解做裸的BFS用到的信息），\(h\)是一个启发函数。
启发函数在不同的情况下是有不同的计算方法的，这要因情况而异。
为了更好定义A*算法，我们还要引入一些函数：\(f^ *(n),g^ *(n),h^ *(n)\)。
首先我们要明确，上面提到的估价函数，是对待扩展节点的一个“估计”，是从启发信息计算而来的，因此从初始状态到正解对应的状态的花费不是实际花费。
\(f^ *(n)=g^ *(n)+h^ *(n)\)表示的是从搜索的起点经过\(n\)状态到达搜索目标的实际最小花费，因此，你可以把\(f(n),g(n),h(n)\)看作这些带*的函数的估计值。
A*算法定义为保证\(h(n)<h^ *(n)\)的A算法，其保证能得到最优解。
我们通过例题入手
P1379 八数码难题
题目描述
在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。
显然这题可以用双向BFS做（起点状态和中点状态模式相同），而且实际上裸的BFS这题也能过。。。
不过既然是在讲A*，就讨论A*怎么解（哇，发现题解有一篇我校巨佬的IDA*QWQ）。
为了使得\(h\)函数一定比\(h^ *(n)\)小，我们考虑构造一个这样的函数。在起始状态，\(h ^*(n)\)显然就是所有位置的数移动到目标状态的位置的所需步数。我们可以假定\(h(n)\)为\(n\)状态时不在目标位置的数的个数。因为显然，这些不再目标位置的数至少要通过一次移动才能到达目标位置。这是一个可行方案。
贴代码：
用了一个map来去除重复状态，其实matrix结构体里面随便咋重载都行，反正装的进去map就行。
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
using namespace std;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct matrix{
int a[5][5];
bool operator<(matrix x) const{
for(int i=1;i<=3;++i)
for(int j=1;j<=3;++j)
if(x.a[i][j]!=a[i][j]) return x.a[i][j]<a[i][j];
return 0;
}
}st,f;
inline int h(matrix a)
{
int tmp=0;
for(int i=1;i<=3;++i)
for(int j=1;j<=3;++j)
if(a.a[i][j]!=st.a[i][j]) tmp++;
return tmp;
}
struct node{
matrix a;
int step;
bool operator<(node x) const{
return x.step+h(x.a)<step+h(a);
}
node(){};
node(matrix _a,int _step){a=_a,step=_step;}
};
priority_queue<node> q;
map<matrix,bool> mp;
int main()
{
st.a[1][1]=1,st.a[1][2]=2,st.a[1][3]=3;
st.a[2][1]=8,st.a[2][2]=0,st.a[2][3]=4;
st.a[3][1]=7,st.a[3][2]=6,st.a[3][3]=5;
char c;
for(int i=1;i<=3;++i)
for(int j=1;j<=3;++j){
scanf("%c",&c);
f.a[i][j]=c-'0';
}
q.push(node(f,0));
while(q.size()){
node x=q.top();q.pop();
if(!h(x.a)){
printf("%d\n",x.step);
return 0;
}
if(mp[x.a]) continue;
mp[x.a]=1;
int nx,ny;
for(int i=1;i<=3;++i)
for(int j=1;j<=3;++j)
if(!x.a.a[i][j]) nx=i,ny=j;
for(int i=0;i<4;++i){
int xx=nx+dir[i][0],yy=ny+dir[i][1];
if(xx>=1&&xx<=3&&yy>=1&&yy<=3){
swap(x.a.a[xx][yy],x.a.a[nx][ny]);
q.push(node(x.a,x.step+1));
swap(x.a.a[xx][yy],x.a.a[nx][ny]);
}
}
}
return 0;
}
如果要加ID的话会更快，这里不详细讲，具体做法跟一般IDBFS是一样的。
P2324 [SCOI2005]骑士精神
跟上面这道题完全一样，没区别，稍微改一下代码就好了。
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#define ll long long
using namespace std;
int dir[8][2]={{1,2},{-1,2},{2,1},{2,-1},{-2,1},{-2,-1},{1,-2},{-1,-2}};
struct matrix{
int a[6][6];
bool operator<(matrix x) const{
for(int i=1;i<=5;++i)
for(int j=1;j<=5;++j)
if(x.a[i][j]!=a[i][j]) return x.a[i][j]<a[i][j];
return 0;
}
}st,f;
inline int h(matrix a)
{
int tmp=0;
for(int i=1;i<=5;++i)
for(int j=1;j<=5;++j)
if(a.a[i][j]!=st.a[i][j]) tmp++;
return tmp;
}
struct node{
matrix a;
int step;
bool operator<(node x) const{
return x.step+h(x.a)<step+h(a);
}
node(){};
node(matrix _a,int _step){a=_a,step=_step;}
};
priority_queue<node> q;
map<matrix,bool> mp;
int main()
{
st.a[1][1]=1,st.a[1][2]=1,st.a[1][3]=1,st.a[1][4]=1,st.a[1][5]=1;
st.a[2][1]=0,st.a[2][2]=1,st.a[2][3]=1,st.a[2][4]=1,st.a[2][5]=1;
st.a[3][1]=0,st.a[3][2]=0,st.a[3][3]=-1,st.a[3][4]=1,st.a[3][5]=1;
st.a[4][1]=0,st.a[4][2]=0,st.a[4][3]=0,st.a[4][4]=0,st.a[4][5]=1;
st.a[5][1]=0,st.a[5][2]=0,st.a[5][3]=0,st.a[5][4]=0,st.a[5][5]=0;
int T;
scanf("%d",&T);
while(T--){
mp.clear();
while(q.size()) q.pop();
char c;
for(int i=1;i<=5;++i)
for(int j=1;j<=5;++j){
scanf(" %c",&c);
if(c=='*') f.a[i][j]=-1;
else f.a[i][j]=c-'0';
}
bool flag=0;
q.push(node(f,0));
while(q.size()){
node x=q.top();q.pop();
if(flag) continue;
if(x.step>15){
printf("-1\n");
flag=1;
}
if(!h(x.a)&&!flag){
printf("%d\n",x.step);
flag=1;
}
if(mp[x.a]) continue;
mp[x.a]=1;
int nx,ny;
for(int i=1;i<=5;++i)
for(int j=1;j<=5;++j)
if(x.a.a[i][j]==-1) nx=i,ny=j;
for(int i=0;i<8;++i){
int xx=nx+dir[i][0],yy=ny+dir[i][1];
if(xx>=1&&xx<=5&&yy>=1&&yy<=5){
swap(x.a.a[xx][yy],x.a.a[nx][ny]);
q.push(node(x.a,x.step+1));
swap(x.a.a[xx][yy],x.a.a[nx][ny]);
}
}
}
}
return 0;
}
就是跑的比较慢啦。
