poj 2449 A*

題意：大意是 有N個station 要求從s點到t點 的第k短路 （不過我看題意說的好像是從t到s 可能是出題人寫錯了）

思路： 這是一道 經典的第k短路算法，只要你會就能過。PS：這也是我第一k短路題 學到了很多新的東西 因爲沒學過A* 算法 所以在網上找了好久，但講了都不是清楚 解題報告也都不帶註釋的 這裏我就附上詳細的解題報告 也好給以後要學的人 一點幫助。

從這題中還真的學到了很多
1.第k短路的算法 A* 還有用邊表實現dij
2.第一次使用優先隊列 這個高級啊！！ 附個優先隊列的一些資料吧

跟queue用法差不多 下面是它的一些操作：

push()：入隊，即插入元素

pop()：出隊，即刪除元素

front()或 top()：讀取隊首元素

back()：讀取隊尾元素

empty()：判斷隊列是否爲空

size()：隊列當前元素

優先隊列容器與隊列一樣，只能從隊尾插入元素，從隊首刪除元素。但是它有一個特性，就是隊列中最大的元素總是位於隊首，所以出隊時，並非按照先進先出的原則進行，而是將當前隊列中最大的元素出隊。這點類似於給隊列裏的元素進行了由大互小的順序排序。元素的比較規則默認按元素值由大到小排序，可以重載“<”操作符來重新定義比較規則。

（注：以下部份資料來源於網上）
所謂A*就是啓發是搜索 說白了就是給搜索一個順序使得搜索更加合理減少無謂的搜索. 如何來確定搜索的順序？..也就是用一個值來表示 這個值爲f[n]..每次搜索取f[x]最小的拓展 那麼這個f[n]=h[n]+g[n]
其中f(n) 是節點n的估價函數，g(n)是在狀態空間中從初始節點到n節點的實際代價，h(n)是從n到目標節點最佳路徑的估計代價。在這裏主要是h(n)體現了搜索的啓發信息，因爲g(n)是已知的。如果說詳細 點，g(n)代表了搜索的廣度的優先趨勢。但是當h(n) >> g(n)時，可以省略g(n),而提高效率。

A*算法的估價函數可表示爲：
f’(n) = g’(n) + h’(n)
這裏，f’(n)是估價函數，g’(n)是起點到終點的最短路徑值，h’(n)是n到目標的最短路經的啓發值。由 於這個f’(n)其實是無法預先知道的，所以我們用前面的估價函數f(n)做近似。g(n)代替g’(n)，但 g(n)>=g’(n) 纔可（大多數情況下都是滿足的，可以不用考慮），h(n)代替h’(n)，但h(n)<=h’(n)纔可（這一點特別的重 要）。可以證明應用這樣的估價函數是可以找到最短路徑的，也就是可採納的。我們說應用這種估價函數的 最好優先算法就是A*算法。
下面以這道題爲例，結合着理解相信你就能理解了！！

//9856K 297MS

#include <stdio.h>
#include <string.h>
#include <queue>
#define M 100010
#define N 1005
const int inf = 0x3f3f3f3f;
using namespace std;
struct E         //鄰接表建邊，to是下個結點，w 是權值 nxt 是下條邊的位置
{
    int to,w,nxt;
}edge[2*M];

struct data    //g 表示起點到當前點的距離，h表終點到當前點的距離
{
    int g,h;
    int to;
    bool operator < (data a) const   //優先隊列的排序（其實也不能這麼講） 使g+h小的在隊首
    {
        return a.h + a.g < h + g;
    }
};
int e,n,src,des,head[N],tail[N],dis[N];//head 是正向邊，tail是逆向邊 dis是des（終點）到各點的距離
void addedge (int cu,int cv,int cw)
{
    edge[e].to = cv;
    edge[e].w = cw;
    edge[e].nxt = head[cu];
    head[cu] = e ++;
    edge[e].to = cu;
    edge[e].w = cw;
    edge[e].nxt = tail[cv];
    tail[cv] = e ++;
}

void dij ()          //dijstra算法求des到各點的距離 用於估價函數h
{
    int i,j,k;
    int vis[N];
    memset (vis,0,sizeof(vis));
    memset (dis,0x3f,sizeof(dis));
    dis[des] = 0;
    for (i = 1;i <= n;i ++)
    {
        k = -1;
        int min = inf;
        for (j = 1;j <= n;j ++)
            if (!vis[j]&&min > dis[j])
            {
                k = j;
                min = dis[j];
            }
       // if (k == -1)      //因爲這裏圖肯定是連通的 可加可不加
       //     break;
        vis[k] = 1;
        for (int u = tail[k];u != -1;u = edge[u].nxt)
        {
            int v;
            v = edge[u].to;
            if (!vis[v]&&dis[v] > dis[k] + edge[u].w)
                dis[v] = dis[k] + edge[u].w;
        }
    }
}

int Astar (int k)    //A*算法求第k短路
{
    int cnt[N];
    data cur,nxt;     //當前結點 下個結點
    priority_queue <data> node;
    memset (cnt,0,sizeof(cnt));
    cur.to = src;             //當前結點初始化 這就不用多說了
    cur.g = 0;
    cur.h = dis[src];
    node.push (cur);
    while (!node.empty())
    {
        cur = node.top ();
        node.pop();
        cnt[cur.to] ++;
        if (cnt[cur.to] > k)//如果當前想拓展的點cnt>k就沒必要拓展了
            continue;        //因爲這個點已經是求到k+1短路了 從這個點繼續往下搜肯定得到的是大於等於k+1短路的路徑
        if (cnt[des] == k)  //找到第K短路 返回
            return cur.g;
        for (int u = head[cur.to];u != -1;u = edge[u].nxt)  //相連的點入隊列
        {
            int v = edge[u].to;
            nxt.to = v;
            nxt.g = cur.g + edge[u].w;
            nxt.h = dis[v];
            node.push (nxt);
        }
    }
    return -1;
}
int main ()
{
    int m,u,v,w,k;
    while (~scanf ("%d%d",&n,&m))
    {
        e = 0;
        memset (head,-1,sizeof (head));
        memset (tail,-1,sizeof (tail));
        while (m --)
        {
            scanf ("%d%d%d",&u,&v,&w);
            addedge (u,v,w);
        }
        scanf ("%d%d%d",&src,&des,&k);
        if (src == des)     //起點和終點相同時，k要++
            k ++;
        dij ();
        int ans = Astar (k);
        printf ("%d\n",ans);
    }
    return 0;
}