【NOIP 2015 Day1 T2】信息传递（dfs || 拓扑排序 || Tarjan）

题目描述 Description
有个同学（编号为 1 到）正在玩一个信息传递的游戏。在游戏里每人都有一个固定的信息传递对象，其中，编号为的同学的信息传递对象是编号为的同学。游戏开始时，每人都只知道自己的生日。之后每一轮中，所有人会同时将自己当前所知的生日信息告诉各自的信息传递对象（注意：可能有人可以从若干人那里获取信息，但是每人只会把信息告诉一个人，即自己的信息传递对象）。当有人从别人口中得知自己的生日时，游戏结束。请问该游戏一共可以进行几轮？

输入描述 Input Description
输入共 2行。
第 1行包含1个正整数n，表示n个人
第 2 行包含n 个用空格隔开的正整数T1 ,T 2 ,……,Tn ， 其中第i个整数Ti表示编号为i
的同学的信息传递对象是编号为 T i 的同学，Ti≤n 且 Ti≠i。
数据保证游戏一定会结束。

输出描述 Output Description
输出共 1行，包含 1个整数，表示游戏一共可以进行多少轮。

样例输入 Sample Input
5
2 4 2 3 1

样例输出 Sample Output
3

数据范围及提示 Data Size & Hint
【输入输出样例 1 说明】

游戏的流程如图所示。当进行完第 3 轮游戏后，4 号玩家会听到 2 号玩家告诉他自己的生日，所以答案为 3。当然，第 3 轮游戏后，2 号玩家、3 号玩家都能从自己的消息来源得知自己的生日，同样符合游戏结束的条件。

对于 30%的数据， ≤ 200；
对于 60%的数据， ≤ 2500；
对于 100%的数据， ≤ 200000。

题解：这道题有很多种做法，一种做法是先把入度为零的点删去，如果有新的入度为零的点，就继续删，这样最后就会只剩下环，然后在这些环里找最小的环输出。可以用一个队列来保存入度为零的点，然后依次删去，把新的入度为零的点加入队列，直到队列为空。然后就可以从任何一个点开始找最小的环。
还有一种做法是用dfs，每次dfs记录一个时间戳和一个起点编号，如果在dfs的过程中遇到一个已经dfs过的点，而且这个点的起点编号和当前点的起点编号相同，就说明dfs找到了一个环，当前时间减去这个点的时间戳就是环的长度。
2016.11.07：今天学了一下Tarjan算法，而且这道题是找最小环，所以可以用Tarjan来做，于是我就又做了一遍。这道题可以直接用Tarjan找最小的强连通分量，当然还要判断一下这里的强连通分量不能是一个点。

代码如下：
第一种做法：

#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int to[210000],e[210000];
bool used[210000];
queue<int> Q;
int main()
{
    int n,ans=0x7fffff;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&to[i]);
        e[to[i]]++;//记录一下这个点的入度 
    }
    for(int i=1;i<=n;i++)
        if(e[i]==0)//如果入度为零加入队列 
        {
            Q.push(i);
            used[i]=1;
        }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        e[to[u]]--;//删去所有无用的点 
        if(e[to[u]]==0)
        {
            Q.push(to[u]);
            used[to[u]]=1;
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(!used[i])
        {
            used[i]=1;
            int sum=1;
            int j=to[i];
            while(!used[j])
            {
                used[j]=1;
                j=to[j];
                sum++;
            }
            if(sum<ans) ans=sum;//找最小环 
        }
    }
    printf("%d",ans);
    return 0;
}

第二种做法：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int MAXV=210000;
int tim[MAXV],used[MAXV],to[MAXV];
int ans=0x7fffff; 
void dfs(int s)
{
    int k=s,tot=0;
    while(true)
    {
        tim[s]=tot++;//记录时间戳
        used[s]=k;//记录从那个点开始搜的
        s=to[s];
        if(used[s]>0)
        {
            if(used[s]==k)
                ans=min(ans,tot-tim[s]);//当前时间减去时间戳就是环的长度
            break;//只要找到用过的点就退出循环，因为后面的点已经全部用过了
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&to[i]);
    for(int i=1;i<=n;i++)
        if(!used[i]) dfs(i);
    printf("%d\n",ans);
    return 0;
} 

Tarjan代码

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int MAXV=500100;
const int MAXE=500100;
int first[MAXV],nxt[MAXE<<1];
int dfn[MAXV],low[MAXV];
int stack[MAXV],scc[MAXV],size[MAXV],du[MAXV];
int n,m,tot,tot1,snum,cnt;
bool in_stack[MAXV];
struct edge
{
    int from,to;
}es[MAXE<<1];
void init()
{
    memset(first,-1,sizeof(first));
    tot=0;
}
void build(int f,int t)
{
    es[++tot]=(edge){f,t};
    nxt[tot]=first[f];
    first[f]=tot;
}
void group(int u)//Tarjan算法求强连通分量 
{
    dfn[u]=low[u]=++tot1;
    stack[++snum]=u;
    in_stack[u]=1;
    for(int i=first[u];i!=-1;i=nxt[i])
    {
        int v=es[i].to;
        if(!dfn[v])
        {
            group(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in_stack[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        cnt++;
        while(stack[snum+1]!=u)
        {
            scc[stack[snum]]=cnt;
            in_stack[stack[snum]]=0;
            size[cnt]++;
            snum--;
        }
    }
}
int read()//刚开始数组开小了，codevs评测TLE，于是加了个手读吗，然并卵╮(╯▽╰)╭ 
{
    int num=0,flag=1;
    char c;
    c=getchar();
    while(c<'0'||c>'9')
    {
        if(c=='-') flag=-1;
        c=getchar();
    }
    while(c<='9'&&c>='0')
    {
        num=num*10+c-'0';
        c=getchar();
    }
    return flag*num;
}
int main()
{
    int minn=0x7fffffff;
    n=read();
    init();
    for(int i=1;i<=n;i++)
    {
        int t;
        t=read();
        build(i,t);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i]) group(i);
    for(int i=1;i<=cnt;i++)
        if(size[i]<minn&&size[i]>1) minn=size[i];//找不是点的最小强连通分量 
    printf("%d\n",minn);
    return 0;
}