POJ-2449 Remmarguts' Date

/************************************************
* Author        :somniloquy
* Created Time  :2015/10/22 9:26:14
 ************************************************/

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int n_max = 1e3 + 5;
const int m_max = 1e5 + 5;
const int INF = 0x3fffffff;
int n, m, pos, s, t, k, ans;
int connect_1[n_max];       //正向连接
int connect_2[n_max];       //反向连接
int sign[n_max];        
int dis[n_max];         //记录终点到各个点的最短路（即 h）
int cnt[n_max];         //记录所有的点的拓展次数（大于k 不继续拓展）
struct node
{
    int Next;
    int to;
    int len;
} edge_1[m_max], edge_2[m_max]; //正向图 反向图
struct star
{
    int data;
    int g;          //实际花费
    int h;          //估计值（即 dis[])
    int f;          //g + h （经过该点再到终点的总花费）
    bool operator < (const star Next) const
    {
        if(Next.f == f)
            return Next.g < g;
        else
            return Next.f < f;  //总是先弹出f最小的
    }
} Now, Next;

void init()         //初始化
{
    memset(connect_1, -1, sizeof(connect_1));
    memset(connect_2, -1, sizeof(connect_2));
    memset(sign, 0, sizeof(sign));
    fill(dis, dis + n_max, INF);
    memset(cnt, 0, sizeof(cnt));
    pos = 0;
}

void add_edge(node* edge, int* connect, int op, int ed, int len)    //加边
{
    edge[pos].Next = connect[op];
    connect[op] = pos;
    edge[pos].to = ed;
    edge[pos].len = len;
}

void SPFA(int src)          //利用反向图 从终点出发 计算出终点到每一点的最短距离（必须利用反向图，因为是单向边）
{
    queue <int> process;
    process.push(src);
    sign[src] = 1;
    dis[src] = 0;
    while(!process.empty())
    {
        int this_op = process.front();
        process.pop();
        sign[this_op] = 0;
        for(int i = connect_2[this_op]; i != -1; i = edge_2[i].Next)
        {
            int this_ed = edge_2[i].to;
            int this_len = edge_2[i].len;
            if(dis[this_op] + this_len < dis[this_ed])
            {
                dis[this_ed] = dis[this_op] + this_len;
                if(!sign[this_ed])
                {
                    process.push(this_ed);
                    sign[this_ed] = 1;
                }
            }
        }
    }
}

void A_star(int op, int ed, int rank)       //从起点出发 利用正向图 不断进行拓展
{
    priority_queue <star> process;
    Now.data = op;              //初始化第一个元素
    Now.g = 0;
    Now.h = dis[op];
    Now.f = Now.g + Now.h;
    process.push(Now);
    while(!process.empty())
    {
        Now = process.top();
        process.pop();
        cnt[Now.data] ++;       //计数
        if(cnt[Now.data] > rank)
            continue;
        if(cnt[ed] == rank)     //达到目标 ans赋值 弹出
        {
            ans = Now.g;
            return;
        }
        for(int i = connect_1[Now.data]; i != -1; i = edge_1[i].Next)       //强制走到这个点 并计算总花费f
        {
            Next.data = edge_1[i].to;
            Next.g = Now.g + edge_1[i].len;
            Next.h = dis[Next.data];
            Next.f = Next.g + Next.h;
            process.push(Next);
        }   
    }   
}

int main(void)
{
    while(~scanf("%d %d", & n, & m))
    {
        init();
        int a, b, t;
        for(int i = 0; i < m; i ++)
        {
            scanf("%d %d %d", & a, & b, & t);
            add_edge(edge_1, connect_1, a, b, t);       //正向建图 A_star用
            add_edge(edge_2, connect_2, b, a, t);       //反向建图 SPFA用
            pos ++;
        }
        scanf("%d %d %d", & s, & t, & k);
        if(s == t)      //题目要求 必须走一条路 当s==t 最短路不应该是0 所以要在k的基础上+1
            k ++;
        SPFA(t);        //终点做起点
        ans = -1;
        A_star(s, t, k);    //A*算法
        printf("%d\n", ans);
    }
        return 0;
}

题目：

输入n m。表示点的个数 边的条数（单向）。
接下来的m行 输入 a b t。表示 a到b的花费t。(a b两个顶点 t边长）
输入 s t k。求s到t的第k短路径长度。
不存在输出-1。
必须走一条路。

题解：

算是一道A*求最短路的模板题了…
我写这道题的最大的错误是没有建反向图。因为是单向边，要从终点出发，要完全反向行走，才能计算终点到各点的最短距离。（因为上一道题是双向边..所以没考虑过..）