hdu 3836 Equivalent Sets（tarjan+缩点）

Problem Description

To prove two sets A and B are equivalent, we can first prove A is a subset of B, and then prove B is a subset of A, so finally we got that these two sets are equivalent.
You are to prove N sets are equivalent, using the method above: in each step you can prove a set X is a subset of another set Y, and there are also some sets that are already proven to be subsets of some other sets.
Now you want to know the minimum steps needed to get the problem proved.

Input

The input file contains multiple test cases, in each case, the first line contains two integers N <=  and M <= .
Next M lines, each line contains two integers X, Y, means set X in a subset of set Y.

 

Output

For each case, output a single integer: the minimum steps needed.

 

Sample Input

 

Sample Output

Hint

Case 2: First prove set 2 is a subset of set 1 and then prove set 3 is a subset of set 1.

 

Source

2011 Multi-University Training Contest 1 - Host by HNU

 

把tarjan复习了一遍

 题目描述：将题目中的集合转换为顶点，A集合是B集合的子集，转换为一条有向边<A,B>，即题目给我们一个有向图，问最少需要添加多少条边使之成为强连通图。
 解题思路:通过tarjan算法找出图中的所有强连通分支，并将每一个强连通分支缩成一个点(因为强连通分量本身已经满足两两互相可达)。
 要使缩点后的图成为强连通图，每个顶点最少要有一个入度和一个出度，一条边又提供一个出度和一个入度。
 所以可以通过统计没有入度的顶点数 noInDegree 和 没有出度的顶点数 noOutDegree。
 所需要添加的边数就是noInDegree和noOutDegree中的最大值。 

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<stack>
 #include<vector>
 using namespace std;
 #define N 20006
 #define inf 1<<26
 int n,m;
 struct Node
 {
     int from;
     int to;
     int next;
 }edge[N<<];
 int tot;//表示边数，边的编号
 int head[N];
 int vis[N];
 int tt;
 int scc;
 stack<int>s;
 int dfn[N],low[N];
 int col[N];
 
 void init()//初始化
 {
     tt=;
     tot=;
     memset(head,-,sizeof(head));
     memset(dfn,-,sizeof(dfn));
     memset(low,,sizeof(low));
     memset(vis,,sizeof(vis));
     memset(col,,sizeof(col));
 }
 
 void add(int s,int u)//邻接矩阵函数
 {
     edge[tot].from=s;
     edge[tot].to=u;
     edge[tot].next=head[s];
     head[s]=tot++;
 }
 
 void tarjan(int u)//tarjan算法找出图中的所有强连通分支
 {
     dfn[u] = low[u]= ++tt;
     vis[u]=;
     s.push(u);
     int cnt=;
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if(dfn[v]==-)
         {
         //    sum++;
             tarjan(v);
             low[u]=min(low[u],low[v]);
         }
         else if(vis[v]==)
           low[u]=min(low[u],dfn[v]);
     }
     if(dfn[u]==low[u])
     {
         int x;
         scc++;
         do{
             x=s.top();
             s.pop();
             col[x]=scc;
             vis[x]=;
         }while(x!=u);
     }
 }
 
 int main()
 {
     while(scanf("%d%d",&n,&m)== && n+m)
     {
 
         init();
 
         scc=;//scc表示强连通分量的个数
         while(m--)
         {
             int a,b;
             scanf("%d%d",&a,&b);
             add(a,b);//构造邻接矩阵
         }
         for(int i=;i<=n;i++)
         {
             if(dfn[i]==-)
             {
                 tarjan(i);
             }
         }
        //printf("%d\n",scc);
 
        int inde[N];
        int outde[N];
        memset(inde,,sizeof(inde));
        memset(outde,,sizeof(outde));
        for(int i=;i<tot;i++)
        {
             int a=edge[i].from;
             int b=edge[i].to;
             if(col[a]!=col[b])
             {
                  inde[col[b]]++;
                  outde[col[a]]++;
            }
        }
 
        int ans1=;
        int ans2=;
        for(int i=;i<=scc;i++)
        {
            if(inde[i]==)
            {
                   ans1++;
            }
            if(outde[i]==)
            {
                  ans2++;
            }
        }
        if(scc==)
        {
            printf("0\n");
            continue;
        }
        printf("%d\n",max(ans1,ans2));
 
     }
     return ;
 }