NOIP 2015 提高组 Day1 信息传递

求最小的环的长度。 没思路大概这已经卡死一小半人。

我的起初的想复杂了。 后来觉得：这道题真简单：n个点，n-1条边，如果没有环的话，这是一棵树。

这些题目应该不可能考察这些非常规的高难度的算法把。

求强联分量

起初的想法，，然后在处理。
这些题目应该不可能考察这些非常规的高难度的算法把。
题外话：网上看了一个好东西：有人提出了这样的算法。显然该无向图存在连通分支。对每个连通分支单独进行考虑。

对于一个连通图，任取一个它的生成树（有算法可以完成这项操作），连通分支中除过这些树枝剩下的边我们称作弦，每一条弦对应该连通图的一个基本回路，无向图的所有回路都可以表示成这些基本回路的直和（边集的并，去掉公共边），所以最小回路一定在这些基本回路里产生。我们现在把这些弦一条一条往里加就可以了。加入一条弦，立即产生一个基本回路，计算此回路边数并记录在一个数组里。去掉此弦，加入另一条弦，会有另一个回路产生，计算边数，保存。把所有的弦都试一遍，得到一个数组，取最小元素对应的弦，把弦加进生成树，就得到最小回路。这样的算法很节省空间。可以得到所有最小回路。

貌似合理：其实不行，看反例：

 -  fence1(1)
 / \ fence2(1),fence3(1)
 --- fence4(3)
/    \ fence5(1),fence6(1)
------fence7(6)
\____/fence 8(1),fence9(1),fence10(1)
可以发现，存在一种最小生成树为:
  -         fence1(1)
 /          fence2(1)
/    \      fence5(1),fence6(1)
\____/      fence8(1),fence9(1),fence10(1)

根据好友“川菜“思路：强联通分量。

#include <iostream>
//#define debug
#include <bits/stdc++.h>
using namespace std;

const int MM=200001;
int  T[MM];
vector<int>  ReT[MM];
bool used[MM];
vector<int> xu;
int huan[MM];

void dfs(int v){
    used[v]=true;
    int next= T[v];
    if( next !=-1 && !used[next] )  {
            used[next]=true;
            dfs( next ) ;
    }
    xu.push_back(v);
}

void dfs2(int v,int k){
    huan[k]++;
    #ifdef debug
    cout <<"v :"<<v <<"  ||"<<"huan:"<<k << " "<< huan[k] <<"  ";
    #endif
    used[v]=true;
    for(int i=0;i<ReT[v].size();i++){
      int next=ReT[v][i];
      if( next !=-1 && !used[next] )  {
            used[next]=true;
            dfs2( next , k ) ;
      }
    }

}

int main()
{
    //freopen("message1.in","r",stdin);
    //freopen("mesaage.out","w",stdout);
    int N; cin>>N;
    memset(T,-1,sizeof(T));
    for(int i=1;i<=N;i++){
        cin>>T[i];
        //ReT[ T[i] ] = i;//这里错了。 反向以后，可能有好几个儿子。
        ReT[ T[i] ].push_back(i);
    }

   #ifdef debug
    for(int i=1;i<=N;i++){
       cout << "i:" <<i <<"next:"<< T[i]<<";" ;
    }
    #endif // debug

    memset(used, 0 ,sizeof(used));
    for(int i=1;i<=N;i++){
        if( !used[i] ) {
             dfs(i);
        }
    }

    memset(used,0,sizeof(used));
    memset(huan,0,sizeof(huan));

    #ifdef debug
     for(int i=0;i<xu.size();i++){
            cout << "xu"<< i << ":" << xu[i]<<"  ";
            cout <<endl;
    }
    #endif // debug

     int k=0;
     for(int i=xu.size()-1;i>=0;i--){
        if( !used[ xu[i] ] ) {
             dfs2( xu[i], ++k );
        }
    }

    int ans=MM;
    for(int i=1;i<=k;i++){
       if( huan[i]!=1) ans = min( huan[i] , ans );
    }
    cout << ans;
    return 0;
}

思路二  拓扑 + DFS
  先拓扑，删掉入度为零的点，剩下的就是环了。 然后DFS
记下每次访问到的节点的时间戳，如果再次访问到该节点，将此时的时间戳，减去上次的时间戳。这应该是正解。
有环的话，只有一个环。 只有一个环吗？ 我想错了！！

先扫描一遍结点，将入度为0的结点入队； 然后从队列里依次取出这些结点，删除它的出边，删除该结点（做删除标记），修改出边结点的入度，如果其入度为0，则入队。 重复上述过程直至队列为空，拓扑过程结束。 剩下的结点一定构成环。
、在扫描一遍结点，遇到入度不为0的结点，就以它为 起点 dfs，查环的长度
 
感觉思路对的，luogu上值通过了10组数据。  写后感： 刚开始 拓扑排序不熟练，通过了6组数据， 还有四组内存超过了。
#include <iostream>

#include <bits/stdc++.h>
using namespace std;

const int MM=200001;
int  T[MM];
int  rudu[MM];
int S;
int ans=MM;
int N;
bool used[MM];

//要优化，否则很多数据通不过

/* 1、先扫描一遍结点，将入度为0的结点入队；
 * 然后从队列里依次取出这些结点，删除它的出边，删除该结点（做删除标记），修改出边结点的入度，如果其入度为0，则入队。
 * 重复上述过程直至队列为空，拓扑过程结束。 剩下的结点一定构成环。
 *
 * 2、在扫描一遍结点，遇到入度不为0的结点，就以它为起点查环的长度，同时删除该结点（做删除标记）。
 *
 */

void tp(){
    queue<int> q;
    for(int v=0; v<=N; v++){
        if( rudu[v]==0 ) {
                  q.push(v);
        }
    }

    while( !q.empty()){
        int f=q.front() ;  q.pop();
        int next = T[f];
        T[f]=-1;
        if(next!=-1)
        {   rudu[next]--;
            if( rudu[next]==0 )  {q.push( next ); }
        }
    }
}

void dfs(int v,int step){
    int next= T[v];
    if( next == S) {
        ans = min( ans, step ) ;
        return;
    }
    if( next !=-1 )  {
            dfs( T[v] , step+1) ;
            used[next]=true;
    }
}

int main()
{
    //freopen("message1.in","r",stdin);
   // freopen("mesaage.out","w",stdout);
     cin>>N;
    memset(rudu,0,sizeof(rudu));
    memset(used, 0 ,sizeof(used));

    for(int i=1;i<=N;i++){
        cin>>T[i];
        rudu[ T[i] ]++;
    }

    tp();
     //这里可以不用深度搜索，直接while语句往下搜索，遇到起点后，统计一下环的长度，也方便
    memset(used, 0 ,sizeof(used));
    for(int i=1;i<=N;i++){
        if( rudu[i]==1 && !used[i] ) {
                S = i;
                used[i]=true;
                dfs(i, 1);
        }
    }

    cout << ans;
    return 0;
}


附： 数据2： 
输入：
50
18 14 38 26 36 27 23 13 21 4 34 41 22 50 47 11 12 11 24 1 47 37 28 48 28 17 396 4 10 48 42 8 2 50 49 32 36 21 20 23 45 5 30 46 19 44 3 20 33
输出：
15 
样例解释：