POJ1236 Network of Schools —— 强连通分量 + 缩点 + 入出度

题目链接：http://poj.org/problem?id=1236

 

Network of Schools

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 19859		Accepted: 7822

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

Source

IOI 1996

 

 

 

题解：

1.利用Tarjan算法求出每个强连通分量，然后进行缩点（以下的分析中，结点是指经过缩点之后的强连通分量）。

2.如果强连通分量的个数为1，即表明题目所给的图为强连通图。故可直接输出答案：1， 0。否则：

首先求出每个强连通分量的入度和出度，然后：

task A：显然，只需要为每个入度为0的结点输入一份资料即可，其余入度不能为0的结点都可以从指向它的结点获取资料。

task B：每增加一条边，图中必有一个的结点入度增加1， 必有一个结点的出度增加1。设图中有a个结点的入度为0， b个结点的出度为0，假设a>=b，那么首先我们可以增加b条边，既能实现图中所有结点的出度都不能为0，但是还剩下a-b个结点的入度为0，此时，我们只需再添加a-b条边，既可以实现图中所有结点的入度都不为0了，所以总共需要添加a条边。当b>a时，需要添加b条边。综上结论：如果图中有a个结点的入度为0， b个结点的出度为0，那么只需添加 max(a,b)条边，即可使原图成为强连通图。前提是原图为简单图，且结点个数大于1。

 

 

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
#define ms(a,b) memset((a),(b),sizeof((a)))
using namespace std;
typedef long long LL;
const double EPS = 1e-8;
const int INF = 2e9;
const LL LNF = 2e18;
const int MAXN = 1e2+10;

struct Edge
{
    int to, next;
}edge[MAXN*MAXN];
int head[MAXN], tot;

int index, Low[MAXN], DFN[MAXN];
int top, Stack[MAXN], Instack[MAXN];
int scc, Belong[MAXN];
int Indegree[MAXN], Outdegree[MAXN];

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

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++index;
    Stack[top++] = u;
    Instack[u] = 1;
    for(int i = head[u]; i!=-1; i = edge[i].next)
    {
        v = edge[i].to;
        if(!DFN[v])
        {
            Tarjan(v);
            Low[u] = min(Low[u], Low[v]);
        }
        else if(Instack[v])
            Low[u] = min(Low[u], Low[v]);
    }

    if(Low[u]==DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = 0;
            Belong[v] = scc;
        }while(v!=u);
    }
}

void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));

    index = scc = top = 0;
    memset(DFN, 0, sizeof(DFN));
    memset(Low, 0, sizeof(Low));
    memset(Instack, 0, sizeof(Instack));

    memset(Indegree, 0, sizeof(Indegree));
    memset(Outdegree, 0, sizeof(Outdegree));
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        for(int u = 1; u<=n; u++)
        {
            int v;
            while(scanf("%d", &v) && v)
                addedge(u, v);
        }

        for(int i = 1; i<=n; i++)
            if(!DFN[i])
                Tarjan(i);

        if(scc==1)
        {
            printf("%d\n%d\n", 1, 0);
            continue;
        }

        for(int u = 1; u<=n; u++)
        {
            for(int i = head[u]; i!=-1; i = edge[i].next)
            {
                int v = edge[i].to;
                if(Belong[u]==Belong[v]) continue;
                Outdegree[Belong[u]]++;
                Indegree[Belong[v]]++;
            }
        }

        int Innum = 0, Outnum = 0;
        for(int i = 1; i<=scc; i++)
        {
            if(Indegree[i]==0) Innum++;
            if(Outdegree[i]==0) Outnum++;
        }

        printf("%d\n%d\n", Innum, max(Innum, Outnum));
    }
}