POJ 2449

Time Limit: 4000MS Memory Limit: 65536K

Description

"Good man never makes girls wait or breaks an appointment!" said the mandarin duck father. Softly touching his little ducks' head, he told them a story.

"Prince Remmarguts lives in his kingdom UDF – United Delta of Freedom. One day their neighboring country sent them Princess Uyuw on a diplomatic mission."

"Erenow, the princess sent Remmarguts a letter, informing him that she would come to the hall and hold commercial talks with UDF if and only if the prince go and meet her via the K-th shortest path. (in fact, Uyuw does not want to come at all)"

Being interested in the trade development and such a lovely girl, Prince Remmarguts really became enamored. He needs you - the prime minister's help!

DETAILS: UDF's capital consists of N stations. The hall is numbered S, while the station numbered T denotes prince' current place. M muddy directed sideways connect some of the stations. Remmarguts' path to welcome the princess might include the same station twice or more than twice, even it is the station with number S or T. Different paths with same length will be considered disparate.

Input

The first line contains two integer numbers N and M (1 <= N <= 1000, 0 <= M <= 100000). Stations are numbered from 1 to N. Each of the following M lines contains three integer numbers A, B and T (1 <= A, B <= N, 1 <= T <= 100). It shows that there is a directed sideway from A-th station to B-th station with time T.

The last line consists of three integer numbers S, T and K (1 <= S, T <= N, 1 <= K <= 1000).

Output

A single line consisting of a single integer number: the length (time required) to welcome Princess Uyuw using the K-th shortest path. If K-th shortest path does not exist, you should output "-1" (without quotes) instead.

Sample Input

Sample Output

题意：

给出 $N$ 个顶点，$M$ 条有向边，求从起点 $S$ 到终点 $T$ 的第 $K$ 短路的长度，路径允许重复经过点和边。

（如果不存在第 $k$ 短路则输出 $-1$。其实不难知道如果从 $S$ 到 $T$ 的某条路径上存在一个环，则必然存在第 $k$ 短路，否则就有可能没有第 $k$ 短路）

（有一个需要注意的点是，此处当 $S=T$ 时，认为最短路径不是零）

题解：

根据优先队列优化Dijkstra算法，我们知道，优先队列里面的可能存在多个元素 $(x,d_1[x]),(x,d_2[x]), cdots$，同时代表着某个节点 $x$ 以及起点到 $x$ 的某条路径的长度。

当从优先队列中第一次取出 $x$ 时，起点到 $x$ 的最短路长度已经得到，那么后续再取出节点 $x$ 显然就是一些次短路径。

由此我们可以想到使用优先队列BFS：

起初优先队列中只存在元素 $(S,0)$，不断从优先队列中取出 $d[x]$ 最小的 $(x,d[x])$，然后沿着从 $x$ 出发的每条有向边 $edge(x,y)$ 都进行扩展，将新的元素 $(y,d[y]=d[x]+w(x,y))$ 入队（本题允许重复经过点和边）。

不难证明，某个状态 $(x,d_1[x])$ 第一次从优先队列中被取出时，就得到了从初态到它的最小代价 $d[x]$。因为此时队列中所有其他状态的代价都大于等于 $d[x]$，是不可能再返回来更新 $d[x]$ 的。

然后，如果按照普通的优先队列BFS做法（即优先队列优化Dijkstra算法），往后若再从队列内取出另一个元素 $(x,d_2[x])$，会将其直接忽略，因为必然不是最优解。

那么，不难想到在本题的优先队列BFS做法中，第 $i$ 次从优先队列中取出的元素 $(x,d_i[x])$，其 $d_i[x]$ 便是从起点到 $x$ 的第 $i$ 短路长度。

所以，最终当终点 $T$ 从队列中第 $K$ 次出队时，便求得了答案。

这样算法最坏的时间复杂度为 $O(K(N+M)log(N+M))$。

MLE代码：

#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
using namespace std;
typedef pair<int,int> pii;
const int maxn=1005;
int n,m,S,T,K;

struct Edge{
    int v,w;
    Edge(){}
    Edge(int _v,int _w) {
        v=_v, w=_w;
    }
};
vector<Edge> E[maxn];

priority_queue< pii, vector<pii>, greater<pii> > Q;
int cnt[maxn];
int bfs()
{
    memset(cnt,0,sizeof(cnt));
    Q.push(make_pair(0,S));
    while(!Q.empty())
    {
        int x=Q.top().second, d=Q.top().first; Q.pop(); cnt[x]++;
        if(cnt[T]==K) return d;
        for(int k=0;k<E[x].size();k++)
        {
            int y=E[x][k].v, w=E[x][k].w;
            if(cnt[y]<K) Q.push(make_pair(d+w,y));
        }
    }
    return -1;
}

int main()
{
    cin>>n>>m;
    for(int i=1,u,v,w;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        E[u].push_back(Edge(v,w));
    }
    cin>>S>>T>>K;
    if(S==T) K++;
    cout<<bfs()<<endl;
}

交了一发，得到MLE $ imes 1$，应该是优先队列内存的元素太多了……

A*优化：

我们知道，A*用一个估价函数 $f(x)$ 来估计当前状态到目标状态所需代价。

在本题中，实际代价 $g(x)$ 即代表：第 $k$ 短路中从 $x$ 到 $T$ 的实际距离。

显然，相应的我们可以设 $f(x)$ 代表：最短路中从 $x$ 到 $T$ 的实际距离。

这样一来，必然满足条件 $f(x) le g(x)$，正确性得以保证。

优先队列内原本存储的是 $(x,d[x])$，现在变为 $(x,d[x]+f(x))$。

A*算法的时间复杂度上界一样是 $O(K(N+M)log(N+M))$，但由于估价函数 $f(x)$ 的作用，很多节点访问次数远小于 $k$，是有较明显的加速的（相应的优先队列内存储的元素会大幅度减少，避免MLE）。

AC代码：

#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
using namespace std;
typedef pair<int,int> pii;
const int maxn=1005;
const int INF=0x3f3f3f3f;
int n,m,S,T,K;

struct Edge{
    int v,w;
    Edge(){}
    Edge(int _v,int _w) {
        v=_v, w=_w;
    }
};
vector<Edge> E[maxn],fE[maxn];
priority_queue< pii, vector<pii>, greater<pii> > Q;

int f[maxn];
bool vis[maxn];
void dijkstra()
{
    memset(f,0x3f,sizeof(f));
    memset(vis,0,sizeof(vis));
    f[T]=0;
    Q.push(make_pair(0,T));
    while(Q.size())
    {
        int u=Q.top().second; Q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=0;i<fE[u].size();i++)
        {
            int v=fE[u][i].v, w=fE[u][i].w;
            if(vis[v]) continue;
            if(f[v]>f[u]+w)
            {
                f[v]=f[u]+w;
                Q.push(make_pair(f[v],v));
            }
        }
    }
}

int cnt[maxn];
int bfs()
{
    memset(cnt,0,sizeof(cnt));
    Q.push(make_pair(0,S));
    while(!Q.empty())
    {
        int x=Q.top().second, d=Q.top().first; Q.pop(); cnt[x]++;
        if(cnt[T]==K) return d;
        for(int k=0;k<E[x].size();k++)
        {
            int y=E[x][k].v, w=E[x][k].w;
            if(cnt[y]<K) Q.push(make_pair(d+w,y));
        }
    }
    return -1;
}

int A_star()
{
    memset(cnt,0,sizeof(cnt));
    Q.push(make_pair(0+f[S],S));
    while(Q.size())
    {
        int u=Q.top().second;
        int d=Q.top().first-f[u];
        Q.pop(); cnt[u]++;
        if(cnt[T]==K) return d;
        for(int i=0,v,w;i<E[u].size();i++)
        {
            v=E[u][i].v, w=E[u][i].w;
            if(cnt[v]<K) Q.push(make_pair(d+w+f[v],v));
        }
    }
    return -1;
}

int main()
{
    cin>>n>>m;
    for(int i=1,u,v,w;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        E[u].push_back(Edge(v,w));
        fE[v].push_back(Edge(u,w));
    }
    cin>>S>>T>>K;
    if(S==T) K++;
    dijkstra();
    cout<<A_star()<<endl;
}