poj2449 Remmarguts' Date A*

学习了一下K短路。

复习一下A*算法的知识。
估价函数f=g+h。g是已走的距离。
启发函数h要满足 h(i)<=h*(i)，被称为可接纳性。
同时又要满足，对于j是i扩展到的节点，g(i)+h(i)<=g(j)+h(j)，被称为一致性。
其实dijkstra算法也是A*算法的一种，它的h函数是0。
而本题设计启发函数为到终点最短路的距离，h=h*，这是显然满足以上两个性质的启发函数。
其实这已经不能叫做“估价”了，是已经知道实际的“价格”了。


由于每次扩展的都是估价最小的路径，而且估价满足一致性，当终点t第k次被扩展，路径长度就是k短路长度了。

这题还有另一种做法：第一个出堆n次的节点的f值就是第k短路的长度。不会证明，难道是数据水了？

注意的地方：
判断非联通性。如果一个点不能到达终点，那就没有扩展它的必要了。
题意貌似要求最短路不能为0。也就是说当起点终点为同个点，k++。
像我这种作死装逼用堆写dij的要注意判断堆为空啊。

嗯，我就不吐槽某人解题报告写了个Dijkstra()函数里面却是spfa了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define NN 1010
#define MM 101000

int fi[NN],ne[MM],v[MM],w[MM];
int fi2[NN],ne2[MM],v2[MM],w2[MM];
int te;
int cnt[NN],dis[NN],us[NN];
int s,t,k,n,m;

struct node{
    int d,i;
    bool operator <(const node &a)const{
        return d>a.d;
    }
};

struct anode{
    int g,i;
    bool operator <(const anode &a)const{
        if (g+dis[i]==a.g+dis[a.i]) return g>a.g;
        else return g+dis[i]>a.g+dis[a.i];
    }
};

void addedge(int f,int t,int val){
    ++te;
    ne[te]=fi[f];
    fi[f]=te;
    v[te]=t;
    w[te]=val;

    ne2[te]=fi2[t];
    fi2[t]=te;
    v2[te]=f;
    w2[te]=val;
}

node make_node(int a,int b){
    node ret;
    ret.d=a;ret.i=b;
    return ret;
}

anode make_anode(int a,int b){
    anode ret;
    ret.g=a;ret.i=b;
    return ret;
}

void dijkstra(){
    int u,vv,e;
    node un;
    memset(us,0,sizeof(us));
    memset(dis,10,sizeof(dis));
    priority_queue<node> q;
    q.push(make_node(0,t));
    dis[t]=0;
    while(!q.empty()){

        while(!q.empty()){
            un=q.top();
            q.pop();
            if (!us[un.i]) break;
            un.i=-1;
        }
        if (un.i==-1) break;
        u=un.i;
        us[u]=1;
        dis[u]=un.d;
        for(e=fi2[u];e!=-1;e=ne2[e]){
            vv=v2[e];
            if (us[vv]) continue;
            if (dis[u]+w2[e]<dis[vv]){
                dis[vv]=dis[u]+w2[e];
                q.push(make_node(dis[vv],vv));
            }
        }
    }
}

int astar(){
    memset(cnt,0,sizeof(cnt));
    if (s==t) k++;
    priority_queue<anode> q;
    anode un;
    int u,e,vv;
    q.push(make_anode(0,s));
    while(!q.empty()){
        un=q.top();
        q.pop();
        u=un.i;
        cnt[u]++;
        //if (cnt[u]==k) {return un.g+dis[u];} //这样也可以，why?
        if (cnt[u]>k) continue;
        if (cnt[t]==k) {return un.g;}

        for(e=fi[u];e!=-1;e=ne[e]){
            vv=v[e];
            if (dis[vv]<=100000000)
                q.push(make_anode(un.g+w[e],vv));
        }
    }
    return -1;
}


int main(){
    int a,b,c,ans,i;
    //freopen("2449in.txt","r",stdin);
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(fi,-1,sizeof(fi));
        memset(fi2,-1,sizeof(fi2));//反图
        te=0;

        for(i=1;i<=m;++i){
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
        }
        scanf("%d%d%d",&s,&t,&k);
        dijkstra();
        if (dis[s]>100000000) ans=-1;
        else ans=astar();
        printf("%d\n",ans);
    }
    return 0;
}