洛谷P2835刻录光盘

最新推荐文章于 2023-04-16 11:07:15 发布

-斯德哥尔摩-

最新推荐文章于 2023-04-16 11:07:15 发布

阅读量631

点赞数 1

CC 4.0 BY-SA版权

分类专栏：强连通分量

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.youkuaiyun.com/yangrui2002/article/details/77920590

强连通分量专栏收录该内容

5 篇文章

订阅专栏

本文介绍了JSOI2005夏令营资料分发问题，通过分析营员间的资料拷贝关系，提出了两种解决方案：一是使用Tarjan算法寻找强连通分量；二是直接统计不能作为资料来源的营员数量。

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

题目描述

在JSOI2005夏令营快要结束的时候，很多营员提出来要把整个夏令营期间的资料刻录成一张光盘给大家，以便大家回去后继续学习。组委会觉得这个主意不错！可是组委会一时没有足够的空光盘，没法保证每个人都能拿到刻录上资料的光盘，又来不及去买了，怎么办呢？！

组委会把这个难题交给了LHC，LHC分析了一下所有营员的地域关系，发现有些营员是一个城市的，其实他们只需要一张就可以了，因为一个人拿到光盘后，其他人可以带着U盘之类的东西去拷贝啊！

可是，LHC调查后发现，由于种种原因，有些营员并不是那么的合作，他们愿意某一些人到他那儿拷贝资料，当然也可能不愿意让另外一些人到他那儿拷贝资料，这与我们JSOI宣扬的团队合作精神格格不入！！！

现在假设总共有N个营员（2<=N<=200），每个营员的编号为1~N。LHC给每个人发了一张调查表，让每个营员填上自己愿意让哪些人到他那儿拷贝资料。当然，如果A愿意把资料拷贝给B，而B又愿意把资料拷贝给C，则一旦A获得了资料，则B，C都会获得资料。

现在，请你编写一个程序，根据回收上来的调查表，帮助LHC计算出组委会至少要刻录多少张光盘，才能保证所有营员回去后都能得到夏令营资料？

输入输出格式

输入格式：

先是一个数N，接下来的N行，分别表示各个营员愿意把自己获得的资料拷贝给其他哪些营员。即输入数据的第i+1行表示第i个营员愿意把资料拷贝给那些营员的编号，以一个0结束。如果一个营员不愿意拷贝资料给任何人，则相应的行只有1个0，一行中的若干数之间用一个空格隔开。

输出格式：

一个正整数，表示最少要刻录的光盘数。

输入输出样例

输入样例#1：

输出样例#1：

这题一开始的思路是并查集，经过 n 次的 10分后，才发现这题的路是单向，而并查集的路是双向。。。

于是果断 Tarjan 强联通。。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define MAXN 250010
using namespace std;
int n,ans=0,c=1,top=1,d=1,colournum=1;
int cstack[MAXN],deep[MAXN],low[MAXN],head[MAXN],indegree[MAXN],colour[MAXN];
bool beque[MAXN];
struct node{
       int last,next,to;
}a[MAXN<<1];
inline int read(){
       int date=0,w=1;char c=0;
       while(c!='-'&&(c<'0'||c>'9'))c=getchar();
       if(c=='-'){w=-1;c=getchar();}
       while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
       return date*w;
}
void add(int x,int y){
     a[c].to=y;a[c].last=x;
     a[c].next=head[x];
     head[x]=c++;
}
void work(int x){
     int t,s;
     beque[x]=true;
     deep[x]=low[x]=d++;
     cstack[top++]=x;
     for(int i=head[x];i;i=a[i].next){
             t=a[i].to;
             if(!deep[t]){
                          work(t);
                          low[x]=min(low[x],low[t]);
                          }
             else if(beque[t])
             low[x]=min(low[x],deep[t]);
             }
     if(low[x]==deep[x]){
                         beque[x]=false;
                         colour[x]=colournum++;
                         do{
                             beque[cstack[top-1]]=false;
                             colour[cstack[top-1]]=colournum-1;
                             }while(cstack[--top]!=x);
                         }
}
int main(){
    int x;
    n=read();
    for(int i=1;i<=n;i++){
            scanf("%d",&x);
            while(x){
                     add(i,x);
                     scanf("%d",&x);
                     }
            }
    for(int i=1;i<=n;i++)
    if(!deep[i])
    work(i);
    for(int i=1;i<c;i++)
    if(colour[a[i].last]!=colour[a[i].to])
    indegree[colour[a[i].to]]++;
    for(int i=1;i<=colournum-1;i++)
    if(!indegree[i])
    ans++;
    printf("%d\n",ans);
    return 0;
}

终于AC了。。

然而发现了更简单的算法，O（n）级别。。。如下：

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int n,x,ans=0;
bool a[210];
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
            scanf("%d",&x);
            while(x){
                     a[x]=true;
                     scanf("%d",&x);
                     }
            }
    for(int i=1;i<=n;i++)
    if(!a[i])
    ans++;
    printf("%d\n",ans==0?1:ans);
    return 0;
}

依旧能 AC。。。