HDU - 5521 Meeting(最短路+思维建边)

题目链接：点击查看

题目大意：给出 n 个点，再给出 m 个集合，对于每个集合中的点来说，其两两都是相互可达的，且花费都相同，问有多少个点，到达点 1 和点 n 的距离相同且最小

题目分析：因为每个集合都是一个完全图，所以直接建图是 n * n 级别的，肯定不可行，又因为我们在求出答案之前，显然是需要正向从点 1 跑一遍迪杰斯特拉，跑出点 1 到每个点的最短距离 d1[ i ] ，然后再从点 n 跑出点 n 到每个点的最短距离 d[ i ] ，剩下的扫一遍维护一下最小值就可以了

那么当务之急是如何不建出整个图，从而求迪杰斯特拉呢，训练的时候我猜了个结论，也就是每个集合至多遍历一次，所以我就改了改迪杰斯特拉的内部实现，没想到就过了。。为什么这样能过呢(乱写的).jpg

因为不会证明上述算法的正确性，所以赛后看民间题解又整理了一种解法

对于每个集合而言，可以建立一个虚拟节点用来连接一个集合中的所有点，以保证任意两个点可以互达，每个点到达虚拟节点的边权为对应的边权，虚拟节点到达每个节点的边权为 0 ，这样最后就能建出一张 n + m 个点的有向图了，剩下的直接跑迪杰斯特拉就好了

代码：
 

#pragma GCC optimize(2)
#pragma GCC optimize("Ofast","inline","-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
#include<unordered_map>
using namespace std;
      
typedef long long LL;
      
typedef unsigned long long ull;
      
const LL inf=0x3f3f3f3f3f3f3f3f;
    
const int N=2e5+100;//顶点数 
 
const int M=2e6+100;//边数 

LL d1[N],d[N];

vector<int>res;
 
template<typename T>
struct Dij
{
	const static int N=2e5+100;
	const static int M=2e6+100;
	struct Edge
	{
		int to,next;
		T w;
	}edge[M];
	 
	int head[N],cnt;//链式前向星 
	
	T d[N];
	 
	bool vis[N];
	 
	void addedge(int u,int v,T w)
	{
		edge[cnt].to=v;
		edge[cnt].w=w;
		edge[cnt].next=head[u];
		head[u]=cnt++;
	}
	 
	struct Node
	{
		int to;
		T w;
		Node(int TO,T W)
		{
			to=TO;
			w=W;
		}
		bool operator<(const Node& a)const
		{
			return w>a.w;
		}
	};
	 
	void Dijkstra(int st)
	{
		priority_queue<Node>q;
		memset(vis,false,sizeof(vis));
		memset(d,0x3f,sizeof(d));
		d[st]=0;
		q.push(Node(st,0));
		while(q.size())
		{
			Node cur=q.top();
			int u=cur.to;
			q.pop();
			if(vis[u])
				continue;
			vis[u]=true;
			for(int i=head[u];i!=-1;i=edge[i].next)//扫描出所有边 
			{
				int v=edge[i].to;
				T w=edge[i].w;
				if(d[v]>d[u]+w)//更新 
				{
					d[v]=d[u]+w;
					q.push(Node(v,d[v]));
				}
			}
		}
	}
	 
	void init()
	{
		memset(head,-1,sizeof(head));
		cnt=0; 
	}
};

Dij<LL>t;
 
int main()
{
#ifndef ONLINE_JUDGE
//  freopen("data.in.txt","r",stdin);
//  freopen("data.out.txt","w",stdout);
#endif
//  ios::sync_with_stdio(false);
	int w;
	cin>>w;
	int kase=0;
	while(w--)
	{
		t.init();
		int n,m;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=m;i++)
		{
			int w,num;
			scanf("%d%d",&w,&num);
			while(num--)
			{
				int x;
				scanf("%d",&x);
				t.addedge(x,n+i,w);
				t.addedge(n+i,x,0);
			}
		}
		t.Dijkstra(1);
		for(int i=1;i<=n;i++)
			d1[i]=t.d[i];
		t.Dijkstra(n);
		for(int i=1;i<=n;i++)
			d[i]=t.d[i];
		LL ans=inf;
		for(int i=1;i<=n;i++)
		{
			if(ans>max(d1[i],d[i]))
			{
				ans=max(d1[i],d[i]);
				res.clear();
				res.push_back(i);
			}
			else if(ans==max(d1[i],d[i]))
				res.push_back(i);
		}
		if(ans==inf)
			printf("Case #%d: Evil John\n",++kase);
		else
		{
			printf("Case #%d: %lld\n",++kase,ans);
			for(int i=0;i<res.size();i++)
				printf("%d%c",res[i],i==res.size()-1?'\n':' ');
		}
	}


















   return 0;
}