[拓扑排序/强联通分量] [NOIP201402] 信息传递

信息传递

题目描述

　　有n个同学（编号为1到n）正在玩一个信息传递的游戏。在游戏里每人都有一个固定的信息传递对象，其中，编号为i的同学的信息传递对象是编号为Ti同学。

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

输入输出格式

　　输入格式：

　　输入共2行。

　　第1行包含1个正整数n表示n个人。

　　第2行包含n个用空格隔开的正整数T1,T2,……,Tn其中第i个整数Ti示编号为i的同学的信息传递对象是编号为Ti的同学，Ti≤n且Ti≠i

　　数据保证游戏一定会结束。

 

　　输出格式：

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

输入输出样例

　　输入样例#1：

　　5
　　2 4 2 3 1

　　输出样例#1：

　　3

说明

　　样例1解释

 

　　游戏的流程如图所示。当进行完第 3 轮游戏后， 4 号玩家会听到 2 号玩家告诉他自

己的生日，所以答案为 3。当然，第 3 轮游戏后， 2 号玩家、 3 号玩家都能从自己的消息

来源得知自己的生日，同样符合游戏结束的条件。

　　对于 30%的数据， n ≤ 200；

　　对于 60%的数据， n ≤ 2500；

　　对于 100%的数据， n ≤ 200000。

 

俺的题解

　　很明显，这道题可以转换为图论中求最小环的问题。

　　

　　（本来还找了一下画图论的图的软件，后来发现PPT的功能已经足够强大= =）

　　把每个同学当做节点，i和Ti之间连有向边。

　　去年刷到这道题时一直觉得环的特征不明显，今年对图论理解深刻了点，就好些了……

　　求环就有很多种方式咯，在这里说两种。

方法一：拓扑排序

　　　　拓扑排序时会不断删掉入度为0的点，然而环中的点入度永远不会为0，于是环被保留了下来。

　　　　凭借这个性质搜索剩下的环中最小的长度。　

　  方法二：求强连通分量

　　　　因为每同学都只有一位固定对象，所以每个节点出度都为1。此时求强连通分量等同于求环。

 

俺的代码

　　方法一：

#include<iostream> 
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
int n;
int ans=10000000;
struct node
{
    int next;
    int cnt;
    bool bj;
    node(){next=0;cnt=0;bj=0;}
}a[200001];
queue <node> que;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].next;
        a[a[i].next].cnt++;//记录入度
    }
    //拓扑
    for(int i=1;i<=n;i++)
    {
        if(a[i].cnt == 0)
        {
            que.push(a[i]);
            a[i].bj=1;
        }
    }
    while(!que.empty())
    {
        node i=que.front();
        que.pop();
        if(--a[i.next].cnt==0)
        {
            que.push(a[i.next]);
            a[i.next].bj=1;
        }
    }

    for(int i=1;i<=n;i++)
    {
        if(a[i].bj==0)
        {
            int j=i,count=0;
            do
            {
                count++;
                a[j].bj=1;
                j=a[j].next;
            }while(j!=i);
            ans=min(ans,count);
        }
    }
    cout<<ans;
    return 0;
}

　　方法二：

/*
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;

int n,scc=0,idx=0,s[200700],low[200700],dfn[200700],top=0; 
bool in_stack[200700];
int ans=10000000;
vector<int> edge[200700];
int length[200700];

void tarjan(int u) {
    dfn[u] = low[u] = ++idx;//init
    s[top++] = u;//压栈  
    in_stack[u] = true;
    for (int i = 0; i < edge[u].size();i++) {
        int v = edge[u][i];
        if (!dfn[v]) {//未被访问过 
            tarjan(v);//continue
            low[u] = min(low[u], low[v]);
        }
        else if (in_stack[v]) {//如果还在栈内 
            low[u] = min(low[u], dfn[v]);
        }
    }
    int size=0;
    if (dfn[u] == low[u]) {//如果u是强联通的根 
        do {
            size++;
            in_stack[s[--top]] = false;//退栈 
        } while (s[top] != u);//走完一个环返回 
        if(size != 1)
            ans=min(ans,size);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int v;
        scanf("%d",&v);
        edge[i].push_back(v);
    }
    for(int i=1;i<=n;i++)
        tarjan(i);
    printf("%d",ans);
    return 0;
}

 

俺的反思

　　　　傻X错误：这张图可能不连通！比如：

 　　

　　所以需要循环tarjan...o(╯□╰)o