POJ 1236 Network of Schools (强连通分量、缩点）

连通图一块概念和定理比较多，要记得东西很多。

注意到 强连通分量是有向图的概念，双连通分支一般是无向图的概念。

两者都和tarjan算法密不可分，但其实算法并不难，就是要开的数组和变量比较多，代码也有一定的灵活性，写的时候要注意细节。并且做题的时候往往都是要用到一些“定理、结论”。熟能生巧，唯有多做。

思路来自于 PKU的《强连通分量》教学材料

题意：

给定一个有向图，求：

1) 至少要选几个顶点，才能做到从这些顶点出 发，可以到达全部顶点

2) 至少要加多少条边，才能使得从任何一个顶 点出发，都能到达全部顶点

思路：

定理：有向无环图中所有入度不为0的点，一定 可以由某个入度为0的点出发可达。 (由于无环，所以从任何入度不为0的 点往回走，必然终止于一个入度为0的 点)

1. 求出所有强连通分量
2. 每个强连通分量缩成一点，则形成一个有 向无环图DAG。
3. DAG上面有多少个入度为0的顶点，问题1的 答案就是多少

4.在DAG上要加几条边，才能使得DAG变成强连通 的，问题2的答案就是多少

加边的方法：
 要为每个入度为0的点添加入边，为每个出度 为0的点添加出边
 假定有 n 个入度为0的点，m个出度为0的点， max(m,n)就是第二个问题的解，其实就是m或n谁更小就在另外n或m个点引一条边指向它们。

【代码】 （有个trick点，原图本身连通的时候prinf(0,1) )

/* ***********************************************
Author        :angon

************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
#define lld %I64d
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scanl(d) scanf("%I64d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define scannl(n,m) scanf("%I64d%I64d",&n,&m)
#define mst(a,k)  memset(a,k,sizeof(a))
#define LL long long
#define N 105
#define mod 1000000007
inline int read(){int s=0;char ch=getchar();for(; ch<'0'||ch>'9'; ch=getchar());for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';return s;}


struct Edge
{
    int v,next;
}edge[N*N];
int head[N],tot;
int belong[N],Stack[N],inStack[N];
int low[N],dfn[N];
int scc,TimeN,top;
int out[N],in[N];
void addedge(int u,int v)
{
    edge[tot].v=v; edge[tot].next=head[u]; head[u] = tot++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++TimeN;
    Stack[top++] = u;
    inStack[u] = 1;
    for(int i=head[u]; ~i; i=edge[i].next)
    {
        int v=edge[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }
        else if(inStack[v])
            low[u] = min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        int v;
        scc++;
        do
        {
            v = Stack[--top];
            inStack[v] = 0;
            belong[v] = scc;
        }while(v!=u);
    }
}

void init()
{
    mst(head,-1); tot=0;
    mst(inStack,0); mst(dfn,0);
    scc = top = TimeN = 0;
    mst(out,0); mst(in,0);
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n;
    while(~scan(n))
    {
        init();
        REPP(u,1,n)
        {
            int v;
            while(scan(v) && v)
                addedge(u,v);
        }
        REPP(u,1,n)
            if(!dfn[u])
                tarjan(u);
        if(scc==1)
        {
            printf("1\n0\n");
            continue;
        }
        REPP(u,1,n)
        {
            for(int i=head[u]; ~i; i=edge[i].next)
            {
                int v=edge[i].v;
                if(belong[u]==belong[v]) continue;
                out[belong[u]]++;
                in[belong[v]]++;
            }
        }
        int c=0,r=0;
        REPP(i,1,scc)
        {
            if(in[i]==0) r++;
            if(out[i]==0) c++;
        }
        printf("%d\n%d\n",r,max(r,c));

    }
    return 0;
}