HDU1827:Summer Holiday【强连通】

最新推荐文章于 2020-05-04 15:57:38 发布

原创最新推荐文章于 2020-05-04 15:57:38 发布 · 340 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#HDU #强连通

强连通专栏收录该内容

5 篇文章

订阅专栏

本文探讨了如何利用图论中的拓扑排序和并行计算原理，设计一种高效的算法来解决群体通知问题，以最小化所需的通知人数和总电话费用。通过构建联系网络并应用相关算法，实现成本效率的提升。

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

Summer Holiday

Time Limit: 10000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2345 Accepted Submission(s): 1100

Problem Description

To see a World in a Grain of Sand
And a Heaven in a Wild Flower,
Hold Infinity in the palm of your hand
And Eternity in an hour.
—— William Blake

听说lcy帮大家预定了新马泰7日游，Wiskey真是高兴的夜不能寐啊，他想着得快点把这消息告诉大家，虽然他手上有所有人的联系方式，但是一个一个联系过去实在太耗时间和电话费了。他知道其他人也有一些别人的联系方式，这样他可以通知其他人，再让其他人帮忙通知一下别人。你能帮Wiskey计算出至少要通知多少人，至少得花多少电话费就能让所有人都被通知到吗？

Input

多组测试数组，以EOF结束。
第一行两个整数N和M（1<=N<=1000, 1<=M<=2000），表示人数和联系对数。
接下一行有N个整数，表示Wiskey联系第i个人的电话费用。
接着有M行，每行有两个整数X，Y，表示X能联系到Y，但是不表示Y也能联系X。

Output

输出最小联系人数和最小花费。
每个CASE输出答案一行。

Sample Input

12 16
2 2 2 2 2 2 2 2 2 2 2 2 
1 3
3 2
2 1
3 4
2 4
3 5
5 4
4 6
6 4
7 4
7 12
7 8
8 7
8 9
10 9
11 10

Sample Output

3 6
AC—code:
#include<cstdio>
#include<cstring>
#include<stack>
#include<vector>
#define MAXN 1005
#define MAXM 2006 
#define INF 0x3f3f3f
#define min(a,b) a>b?b:a
using namespace std;
int low[MAXN],dfn[MAXN],scc_cnt,dfs_clock;
int sccno[MAXN];
vector<int>scc[MAXN];
stack<int>s;
bool instack[MAXN];
struct Edge
{
	int from,to,next;
}edge[MAXM];
int head[MAXN],edgenum;
int init()
{
	edgenum=0;
	memset(head,-1,sizeof(head));
}
void add(int a,int b)
{
	Edge E={a,b,head[a]};
	edge[edgenum]=E;
	head[a]=edgenum++;
}
void tarjan(int u)
{
	int v;
	low[u]=dfn[u]=++dfs_clock;
	s.push(u);
	instack[u]=1;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		v=edge[i].to;
		if(!dfn[v])
		{
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(instack[v])
			low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u])
	{
		scc_cnt++;
		scc[scc_cnt].clear();
		for(;;)
		{
			v=s.top();
			s.pop();
			instack[v]=0;
			sccno[v]=scc_cnt;
			scc[scc_cnt].push_back(v);
			if(v==u)
				break;
		}
	}
}
void find_cut(int r)
{
	memset(low,0,sizeof(low));
	memset(dfn,0,sizeof(dfn));
	memset(sccno,0,sizeof(sccno));
	memset(instack,0,sizeof(instack));
	dfs_clock=scc_cnt=0;
	for(int i=1;i<=r;i++)
		if(!dfn[i])
			tarjan(i);
}
vector<int>G[MAXN];
int out[MAXN],in[MAXN];
void suodian()
{
	int i;
	for(i=1;i<=scc_cnt;i++)
		G[i].clear(),in[i]=out[i]=0;
	for(i=0;i<edgenum;i++)
	{
		int u=sccno[edge[i].from];
		int v=sccno[edge[i].to];
		if(u!=v)
			G[u].push_back(v),out[u]++,in[v]++; 
	 } 
}
int main()
{
	int a,b,n,i,m,cost[MAXN];
	while(scanf("%d%d",&n,&m)!=EOF) 
	{
		init();
		for(i=1;i<=n;i++)
			scanf("%d",&cost[i]);
		while(m--)
		{
			scanf("%d%d",&a,&b);
			add(a,b);
		}
		find_cut(n);
		suodian();
		int ans1=0,ans2=0;
		int val[MAXN];
		for(i=1;i<=scc_cnt;i++)
		{
			if(in[i]==0)
				ans1++;
			val[i]=INF;
		}
		for(i=1;i<=n;i++)
		{
			int t=sccno[i];
			if(in[t]==0)
				val[t]=min(val[t],cost[i]);	
		}
		for(i=1;i<=scc_cnt;i++)
		{
			if(val[i]!=INF)
			{
				ans2+=val[i];
			}	
		}
		printf("%d %d\n",ans1,ans2);
	 } 
	 return 0;
}