POJ-1236 Network of Schools 【强连通分量+缩点】

Description

A number of schools are connected to a computer network. Agreements have been developed among those schools: each school maintains a list of schools to which it distributes software (the “receiving schools”). Note that if B is in the distribution list of school A, then A does not necessarily appear in the list of school B
You are to write a program that computes the minimal number of schools that must receive a copy of the new software in order for the software to reach all schools in the network according to the agreement (Subtask A). As a further task, we want to ensure that by sending the copy of new software to an arbitrary school, this software will reach all schools in the network. To achieve this goal we may have to extend the lists of receivers by new members. Compute the minimal number of extensions that have to be made so that whatever school we send the new software to, it will reach all other schools (Subtask B). One extension means introducing one new member into the list of receivers of one school.

Input

The first line contains an integer N: the number of schools in the network (2 <= N <= 100). The schools are identified by the first N positive integers. Each of the next N lines describes a list of receivers. The line i+1 contains the identifiers of the receivers of school i. Each list ends with a 0. An empty list contains a 0 alone in the line.

Output

Your program should write two lines to the standard output. The first line should contain one positive integer: the solution of subtask A. The second line should contain the solution of subtask B.

Sample Input

5
2 4 3 0
4 5 0
0
0
1 0

Sample Output

1
2

---

题解：

题目比较简单，先算出强连通分量，再缩点，算出缩点后图的每个点的入度和出度，可以发现，只要给每个入度为0的点分配软件，就是最优策略（因为入度大于0的点一定可以从前一个点获得），B任务的解就是max(入度为0的点数，出度为0的点数），易知要使图强连通，尾接到头是最优方案，谁大谁就是最终解。（注意：如果强连通分量只有一个的时候一定要令ans2=0,因为那时即使所有点的入度出度虽然不为0但根据该算法是不计算，亲测不特判会WA）

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<set>
#include<queue>
#include<stack>
using namespace std;
#define M(a, b) memset(a, b, sizeof(a))
#define INF 0x3f3f3f3f
const int N = 100 + 5;
int pre[N], sccno[N], dfs_clock, scc_cnt;
int ind[N], od[N];
vector<int> G[N];
stack<int> S;

int dfs(int u) {
    int lowu = pre[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i];
        if (!pre[v]) {
            int lowv = dfs(v);
            lowu = min(lowu, lowv);
        }
        else if (!sccno[v]) {
            lowu = min(lowu, pre[v]);
        }
    }
    if (lowu == pre[u]) {
        ++scc_cnt;
        while (true) {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
    return lowu;
}

void find_scc(int n) {
    M(pre, 0); M(sccno, 0);
    dfs_clock = scc_cnt = 0;
    for (int i = 0; i < n; ++i) 
        if (!pre[i]) dfs(i); 
}

int main() {
    int n, v;
    while (~scanf("%d", &n)) {
        for (int u = 0; u < n; ++u) {
            while(true) {
                scanf("%d", &v); --v;
                if (v == -1) break;
                G[u].push_back(v);
            }
        }
        find_scc(n);
        M(ind, 0); M(od, 0);
        for (int u = 0; u < n; ++u)
            for (int i = 0; i < G[u].size(); ++i) {
                int v = G[u][i];
                if (sccno[u] != sccno[v]) {
                    od[sccno[u]]++, ind[sccno[v]]++;
                }
            }
        int in0 = 0, out0 = 0;
        for (int i = 1; i <= scc_cnt; ++i) {
            if (!ind[i]) in0++;
            if (!od[i]) out0++;
        }
        int ans2 = max(in0, out0);
        if (scc_cnt == 1) ans2 = 0;
        printf("%d\n%d\n", in0, ans2);
    }

    return 0;
}