【POJ 1236】Network of Schools 题解（Tarjan算法求有向图的强连通分量）

许多学校都与计算机网络相连。这些学校之间已经达成了协议：每所学校都有一份分发软件的学校名单（“接收学校”）。注意，如果B在学校A的分发列表中，那么A不一定出现在学校B的列表中
您需要编写一个程序，计算必须接收新软件副本的学校的最小数量，以便软件根据协议（子任务a）到达网络中的所有学校。作为进一步的任务，我们希望确保通过向任意学校发送新软件的副本，该软件将到达网络中的所有学校。为了实现这一目标，我们可能必须扩大新成员的接收者名单。计算必须进行的扩展的最小数量，以便无论我们向哪个学校发送新软件，它都能到达所有其他学校（子任务B）。一次延期意味着在一所学校的接收名单中引入一名新成员。

输入
第一行包含整数N：网络中的学校数量（2<=N<=100）。学校由前N个正整数标识。接下来的N行中的每一行描述了一个接收器列表。行i+1包含学校i的接收者的标识符。每个列表以0结尾。空列表行中仅包含一个0。
输出
您的程序应该向标准输出写入两行。第一行应该包含一个正整数：子任务A的解。第二行应该包含子任务B的解。

Sample
Input
5
2 4 3 0
4 5 0
0
0
1 0
Output
1
2

思路

用Tarjan算法求强连通分量，记录每个点所属的强连通分量序号。遍历每个点的邻接点，若该点与其邻接点所属的强连通分量序号不同，则将该点所属的强连通分量的出度加一，将其邻接点所属的强连通分量的入度加一。若图中只有一个强连通分量，则只要将软件发给任一学校，就能让软件到达所有学校，不需要添加接收名单；若图中不止一个强连通分量，则统计入度为0的强连通分量的个数zeroIn和出度为0的强连通分量的个数zeroOut。至少需要发送zeroIn次才能覆盖到所有学校，至少需要添加的接收名单数取zeroIn和zeroOut两者较大值。

AC代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <stack>
#define AUTHOR "HEX9CF"
using namespace std;

const int maxn = 100005;

struct Snode
{
    int to;
    int next;
} edge[maxn];
int head[maxn];
int cnt = 0;

// tarjan
int num = 0;
int dfn[maxn], low[maxn];
bool vis[maxn];
stack<int> s;
int scc = 0;
int belong[maxn], inDeg[maxn], outDeg[maxn];
int zeroIn = 0;
int zeroOut = 0;

void add(int u, int v)
{
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void print(int x)
{
    for (int j = 1; j <= x; j++)
    {
        cout << j << "-";
        for (int i = head[j]; ~i; i = edge[i].next)
        {
            cout << edge[i].to;
        }
        cout << endl;
    }
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++num;
    vis[u] = true;
    s.push(u);
    for (int i = head[u]; ~i; i = edge[i].next)
    {
        int v = edge[i].to;
        if (!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (vis[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    // SCC
    if (low[u] == dfn[u])
    {
        int v;
        do
        {
            v = s.top();
            s.pop();
            belong[v] = scc;
            vis[v] = false;
            // cout << v;
        } while (v != u);
        // cout << endl;
        scc++;
    }
}

int main()
{
    int n;
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(inDeg, 0, sizeof(inDeg));
    memset(outDeg, 0, sizeof(outDeg));
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        int in;
        while (cin >> in)
        {
            if (!in)
            {
                break;
            }
            add(i, in);
        }
    }
    // print(n);
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
        {
            tarjan(i);
        }
    }
    for (int u = 1; u <= n; u++)
    {
        for (int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            if (belong[u] != belong[v])
            {
                outDeg[belong[u]]++;
                inDeg[belong[v]]++;
            }
        }
    }
    if (scc == 1)
    {
        cout << 1 << endl
             << 0 << endl;
    }
    else
    {
        for (int i = 0; i < scc; i++)
        {
            if (!inDeg[i])
            {
                zeroIn++;
            }
            if (!outDeg[i])
            {
                zeroOut++;
            }
        }
        cout << zeroIn << endl
             << max(zeroIn, zeroOut) << endl;
    }
    return 0;
}