POJ -2449(第K短路,A*)

题目大意:
就是求第K短路

---

对A*的理解:
A*更像是启发式搜索与宽搜的综合体.对于宽搜来说,我们总是能够得到正确的答案,即最短值.但美中不足的是时间消耗太高.同样,有阴有阳,或许是为了弥补BFS的不足,又有启发式搜索,即写一个估价函数(heuristic),来评估当前道路的代价值.但我们不能做到评估与正确值完美重合(match~~这不是废话吗!!!),所以就经常会错过潜在的最优答案.此时我们就能够较快的得较优解(good),而对于最优解(perfect)就无能为力了.
所以,我们就采用A*.
A*的实质:
f(x)=h(x)+g(x)
正如当前所说的,f是我们所需要对比的值,而h是评估到目标点的距离,g为此时从s到x的代价(s为源点,t为目标点).然后就是喜闻乐见的优先队列了

速度还是精度?
取决于对于heuristic的理解,我们假设p(x)代表正确答案(即perfect).那么:
1°:若h(x) < p(x) 我们必定能够得到正确答案,但拓展点可能很多,这是速度变慢的原因
2°:若h(x) > p(x) 此时,拓展点将变得很少,但将错过正确值
特殊的情况:相等,很快并且正确

---

Code:

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<queue>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
const int maxn=1e3+10,maxm=1e5+10;
struct edge{
    int to,val,next;
    edge(int to=0,int val=0,int next=0):to(to),val(val),next(next){}
}e[maxm],e2[maxm];
int s,t,k;
struct node
{
    int to,g,f;
    bool operator <(const node &x)const {
        if(x.f==f) 
            return x.g<g;
        return x.f<f;
    }
};
int n,m,len,len2,last[maxn],last2[maxn];
const int inf=0x3f3f3f;
void init()
{
    memset(last,-1,sizeof(last));
    memset(last2,-1,sizeof(last2));
    len=len2=0;
}
void addedge(int from,int to,int val)
{
    e[++len]=edge(to,val,last[from]); last[from]=len;
}
void addedge2(int from,int to,int val)
{
    e2[++len2]=edge(to,val,last2[from]); last2[from]=len2;
}
int dis[maxn];
bool spfa(int s){
    queue<int> q;
    int inq[maxn];
    fo(i,0,n) inq[i]=0,dis[i]=inf;
    dis[s]=0;
    q.push(s); inq[s]++;;
    while(!q.empty()){
        int cur=q.front();
        q.pop();
        inq[cur]--;
            if(inq[cur]>n) return 0;
        for(int i=last2[cur];i!=-1;i=e2[i].next){
            int id=e2[i].to;
            if(dis[id]>dis[cur]+e2[i].val)
            {
                dis[id]=dis[cur]+e2[i].val;
                if(!inq[id])
                {
                    inq[id]++;
                    q.push(id);
                }
            }
        }
    }
    return 1;
}
int A_star(int s,int t,int k){
    node ea,ne;
    int cnt=0;
    priority_queue<node>Q;
    if(s==t) k++;
    if(dis[s]==inf) return -1;
    ea.to=s;//从源点开始 
    ea.g=0;//初始值为零 
    ea.f=ea.g+dis[ea.to];//f=h(x)+g(x) 
    Q.push(ea);//压入队列 

    while(!Q.empty()){
        ea=Q.top();//找出最小点 
        Q.pop();//弹出 
        if(ea.to==t) cnt++;//若找到一条 
        if(cnt==k) return ea.g;//已经找到时 
        for(int i=last[ea.to];i!=-1;i=e[i].next){//找它所接的边 
            ne.to=e[i].to;//压入的新点 
            ne.g=ea.g+e[i].val;//由ea拓展而来,加上比边权等于自己的值 
            ne.f=ne.g+dis[ne.to];//f(x)=g(x)+h(x) 
            Q.push(ne);//压入 
        }
    }
    return -1;
}
int main(){
    while(~scanf("%d%d",&n,&m))
    {
        init();
        fo(i,1,m)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
            addedge2(b,a,c);
        }
        scanf("%d%d%d",&s,&t,&k);
        spfa(t);
        printf("%d\n",A_star(s,t,k));
    }
    return 0;
}

PS:思路:
反向建边,然后求最短路
进队
求值