首先讲讲A*算法吧。众所周知,A*算法就是启发式搜索,基本形式就是这样:f(x)=g(x)+h(x);其中f(x)代表在x点所需要的总代价,而g(x)代表:从源点到x点已经耗费的实际代价,h(x)代表从x到终点需要的估计代价,这个函数是一个估计值.而从x到终点真正需要的代价为h*(x),在整个启发式搜索中我们必须保证h(x)<=h*(x);不然的话会由于对当前的估价值过高,则会引起答案的错误。构建A*的关键在于准确的规划一个h(x)函数,使得接近h*(x),这样的搜索会使得答案又快又准。可以想象h(x)过小会使得解空间过大,这样搜索出来的结果会很准确但是速度太慢,而对h(x)的过高估计,即估计代价太大会使得结果不准确。
这样我们可以理解了BFS的搜索过程,BFS的搜索过程中没有考虑到h(x)的估计代价,也就是说h(x)=0,只考虑g(x)的实际代价。这样根据实际代价来进行搜索,虽然可以说是很恶心的A*,同样地我们可以知道,BFS的解空间确实很大。
第一次写A*,目前只会应用在K短路上。不过也有点感觉了,关键在于h(x)的设计!
描述一下怎样用启发式搜索来解决K短路。
首先我们知道A*的基础公式:f(x)=g(x)+h(x);对h(x)进行设计,根据定义h(x)为当前的x点到目标点t所需要的实际距离。也就是说x->t距离,由于有很多的节点都是到t的距离,为了计算这个估计值,当然必须先算出x->t的最短路径长度。显然x的值很多而t的值只有一个,对每个x去求单源点最短路径当然不划算!于是反过来做,从t点出发到其他点的单源点最短路径,这样吧估价函数h(x)都求出来,注意这样求出来的h(x)=h*(x);
然后就可以对构造完的h(x)开始启发式搜索了。
首先的点当然就是定义头结点了,头结点的已消耗代价为0,估计代价为h[s],下一个点为v;进入队列,开始for循环。每次取出队头的f(x)最小的节点对其他节点进行拓展。对当前节点的拓展次数++,若当前节点的拓展次数超过K,显然不符合要求,则不进行拓展。若对t节点的拓展次数恰好为K,则找到了所需要的。对当前节点的拓展次数即为到当前节点的第几短路。找到需要节点的K短路后,返回g(t)即可,也就是通过K次拓展的实际消耗的长度。
在for循环中的入队情况:当前节点的可拓展所有边,的所有状态都入队,当前节点到拓展节点的实际代价为当前节点的实际代价+两节点之间的边长。下个节点就是拓展节点,估计函数的值则为拓展节点到目标节点的距离h(x);
#define N 1004
const int INF = (1<<30);
int n,m;
int dis[N];//当前点到终点的最短距离
bool vis[N];
struct node{
int v;//下一个点
int dis;//距离
};
struct edge{
int v;
int w;
friend bool operator < (edge a,edge b){//重载为小根堆
return a.w+dis[a.v] > b.w+dis[b.v];
}
};
vector<node> mp[N];//正向邻接表
vector<node> remp[N];//反向邻接表
void init(){
int i;
for(i=0;i<=n;i++){
mp[i].clear();
remp[i].clear();
}
}
//用spfa求点到终点的最短距离
bool SPFA(int s){//s是源点编号
queue<int> qq;
int i;
for(i=1;i<=n;++i){
dis[i] = INF; //将除源点以外的其余点的距离设置为无穷大
vis[i] = 0;
}
dis[s] = 0; //源点的距离为0
vis[s] = 1;
qq.push(s);
int u,v;
while(!qq.empty()){
u = qq.front();
qq.pop();
vis[u] = 0;
for(i=0;i<remp[u].size();i++){
node p = remp[u][i];
if(dis[p.v] > p.dis + dis[u]){
dis[p.v] = p.dis + dis[u];
if(!vis[p.v]){
vis[p.v] = 1;
qq.push(p.v);
}
}
}
}
return true;
}
//A*算法求K短路f(x) = g(x)+h(x)f(x)代表在x点所需要的总代价,
//g(x)代表从源点到x点已经耗费的实际代价,h(x)代表从x到终点需要的估计代价
int Astar(int s,int t,int k){//源点,目标点,k短路
if(s==t)k++;//源点与终点一样时k+1
if(dis[s]==INF)return -1;//不能到达终点
edge n1,n2;
priority_queue<edge> pp;//优先队列,每次取出f最小
int cnt[N];
memset(cnt,0,sizeof(cnt));//计算k短路
n1.v = s;
n1.w = 0;
pp.push(n1);
while(!pp.empty()){
n1 = pp.top();
pp.pop();
cnt[n1.v]++;
int len = n1.w;
if(cnt[n1.v]>k)continue;
if(cnt[t] == k)return len;
for(int i = 0;i<mp[n1.v].size();i++){
n2.v = mp[n1.v][i].v;//与n1相邻的下一点
n2.w = mp[n1.v][i].dis+len;
pp.push(n2);
}
}
return -1;
}
int main(){
while(scanf("%d%d",&n,&m) != -1){
int i,j;
init();
while(m--){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
node tmp;
tmp.v = v;
tmp.dis = w;
mp[u].push_back(tmp);
tmp.v = u;
remp[v].push_back(tmp);
}
int s,t,k;
scanf("%d%d%d",&s,&t,&k);
SPFA(t);
printf("%d\n",Astar(s,t,k));
}
return 0;
}