NYOJ 120 校园网络

校园网络

时间限制：3000 ms  |  内存限制：65535 KB

难度：5

 

描述

南阳理工学院共有M个系，分别编号1~M,其中各个系之间达成有一定的协议，如果某系有新软件可用时，该系将允许一些其它的系复制并使用该软件。但该允许关系是单向的，即：A系允许B系使用A的软件时，B未必一定允许A使用B的软件。

现在，请你写一个程序，根据各个系之间达成的协议情况，计算出最少需要添加多少个两系之间的这种允许关系，才能使任何一个系有软件使用的时候，其它所有系也都有软件可用。

 

输入

第一行输入一个整数T，表示测试数据的组数(T<10)
每组测试数据的第一行是一个整数M，表示共有M个系(2<=M<=100)。
随后的M行，每行都有一些整数，其中的第i行表示系i允许这几个系复制并使用系i的软件。每行结尾都是一个0，表示本行输入结束。如果某个系不允许其它任何系使用该系软件，则本行只有一个0.

输出

对于每组测试数据，输出最少需要添加的这种允许关系的个数。

样例输入

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

样例输出

2

来源

POJ改编

上传者

张云聪

解题：强连通算法+缩点。然后看缩点后的图，某点入度为0，加1，如果出度为0 再加1.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <climits>
#include <algorithm>
#include <cmath>
#include <stack>
#define LL long long
#define INF 0x3f3f3f
using namespace std;
const int maxn = 110;
vector<int>g[maxn],mp[maxn];
stack<int>s;
int low[maxn],dfn[maxn],belong[maxn],iindex;
bool instack[maxn],in[maxn],out[maxn];
int scc,n;
void tarjan(int u) {
    dfn[u] = low[u] = ++iindex;
    instack[u] = true;
    s.push(u);
    int v;
    for(int i = 0; i < g[u].size(); i++) {
        v = g[u][i];
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u],low[v]);
        } else if(instack[v] && low[u] > dfn[v]) low[u] = dfn[v];
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = s.top();
            instack[v] = false;
            belong[v] = scc;
            s.pop();
        } while(v != u);
    }

}
int main() {
    int t,i,j,u,v,ans;
    scanf("%d",&t);
    while(t--) {
        scanf("%d",&n);
        for(i = 0; i <= n; i++) {
            g[i].clear();
            low[i] = dfn[i] = 0;
            instack[i] = false;
            mp[i].clear();
        }
        for(i = 1; i <= n; i++) {
            while(scanf("%d",&v)&&v) {
                g[i].push_back(v);
            }
        }
        while(!s.empty()) s.pop();
        ans = scc = iindex = 0;
        for(i = 1; i <= n; i++)
            if(dfn[i]) tarjan(i);
        for(i = 1; i <= n; i++) {
            for(j = 0; j < g[i].size(); j++) {
                if(belong[i] != belong[g[i][j]]) {
                    mp[belong[i]].push_back(belong[g[i][j]]);
                }
            }
        }
        ans = 0;
        memset(in,false,sizeof(in));
        memset(out,false,sizeof(out));
        for(i = 1; i <= n; i++) {
            for(j = 0; j < g[i].size(); j++) {
                out[i] = true;
                in[g[i][j]] = true;
            }
        }
        for(i = 1; i <= n; i++) {
            if(!in[i]) ans++;
            if(!out[i]) ans++;
        }
        printf("%d
",ans);
    }
    return 0;
}