Meeting HDU - 5521 （单源最短路）

最新推荐文章于 2019-03-09 16:01:26 发布

latstars

最新推荐文章于 2019-03-09 16:01:26 发布

阅读量305

点赞数

CC 4.0 BY-SA版权

分类专栏：单源最短路文章标签：图论

本文链接：https://blog.youkuaiyun.com/li7879/article/details/77725461

单源最短路专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种解决两个人从不同起点出发，在由多个相互连接的城市群中寻找最短相遇时间和地点的问题。通过将城市群抽象为有向图，并利用单源最短路径算法，实现了高效的求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

给你n个点，然后有m个城市群，城市群之间相互可以在ti时间内到达，现在问两个人从1和n同时出发，最少需要花费多少时间相遇，然后输出可能的相遇地点。

思路：

首先是间城市群转化为有向图，每个城市群增加一个点，从每个城市有一条出边和一条入边，权值是ti/2（实际代码实现的时候为了避免浮点数，都乘了2），然后这个用少量的边就满足了题目的城市群互达的条件了。
然后就从1和n做一遍单源最短路就好了，对它们到达某个点的时间a[i]和b[i]取最大值，这个值就是两人在这里相遇所需要的时间，然后找个最小的就是答案了，再把方案输出就好了。
写的时候数组的大小名写错了，wa了一发，好像这种错误不是一次两次了，警记交之前看一遍

代码：

#define debug printf
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<map>
#include<vector>
#include<queue>
using namespace std;
typedef long long LL;
const int maxn=1e5+100;
const int maxm=3e6+100;
int T;
int n,m;
int kase=0;
struct Edge{
    int v,w,next;
    Edge(){}
    Edge(int v,int w,int next)
    :v(v),w(w),next(next){}
};
const int maxnode=1e6+maxn;
Edge edges[maxm];
int head[maxnode];
int edgescnt;
LL times[maxnode],timed[maxnode];
bool viss[maxnode],visd[maxnode];
const LL INF=1e18;
void initEdge();
void AddEdge(int u,int v,int w);
void Dijkstra(int s,LL * d,int n,bool done[]);
void solve();
int main()
{
    scanf("%d",&T);
    kase=0;
    while(T--){
        kase++;
        solve();
    }
    return 0;
}
void initEdge()
{
    memset(head,-1,sizeof(head));
    edgescnt=0;
}
void AddEdge(int u,int v,int w)
{
    edges[edgescnt]=Edge(v,w,head[u]);
    head[u]=edgescnt++;
}
void solve()
{
    scanf("%d %d",&n,&m);
    initEdge();
    int time,sz,u;
    for(int i=1;i<=m;i++){
        scanf("%d %d",&time,&sz);
        for(int j=1;j<=sz;j++){
            scanf("%d",&u);
            AddEdge(u,i+n,time);
            AddEdge(i+n,u,time);
        }
    }
    Dijkstra(1,times,n+m,viss);
    Dijkstra(n,timed,n+m,visd);
//  for(int i=1;i<=n+m;i++){
//        debug("%d %lld %lld\n",i,times[i],timed[i]);
//  }
    LL ans=INF;
    LL tmpmin=INF;
    for(int i=1;i<=n;i++){
        tmpmin=max(times[i],timed[i]);
        if(tmpmin<ans){
            ans=tmpmin;
        }
    }
    if(ans==INF){
        printf("Case #%d: Evil John\n",kase);
        return;
    }
    vector<int> res;
    for(int i=1;i<=n;i++){
        tmpmin=max(times[i],timed[i]);
        if(tmpmin==ans){
            res.push_back(i);
        }
    }

    printf("Case #%d: %lld\n",kase,ans/2);
    for(int i=0;i<res.size();i++){
        if(i!=0)    printf(" ");
        printf("%d",res[i]);
    }
    printf("\n");
}

struct HeapNode{
    LL d;
    int u;
    HeapNode(){}
    HeapNode(LL d,int u)
    :d(d),u(u){}

    bool operator < (const HeapNode & rhs) const
    {
        return d>rhs.d;
    }
};
void Dijkstra(int s,LL * d,int n,bool done[])
{
    priority_queue<HeapNode> Q;
    for(int i=1;i<=n;i++)   d[i]=INF;
    d[s]=0;
    for(int i=1;i<=n;i++)   done[i]=false;
    Q.push(HeapNode(0,s));
    while(!Q.empty()){
        HeapNode x=Q.top();Q.pop();
        int u=x.u;
        if(done[u]) continue;
        done[u]=true;
        for(int e=head[u];e!=-1;e=edges[e].next){
            int v=edges[e].v,w=edges[e].w;
            if(d[v]>d[u]+LL(w)){
                d[v]=d[u]+LL(w);
                Q.push(HeapNode(d[v],v));
            }
        }
    }
}