POJ 1236 Network of Schools

POJ 1236 Network of Schools

图论，有向图强连通分量，targan板子

传送门：POJ

---

题意

一个计算机网络，计算机之间 单向 传递软件。

问1，初始至少需要向多少个学校发放软件，使得网络内所有的学校最终都能得到软件。

问2，至少需要添加几条传输线路(边)，使任意向一个学校发放软件后，经过若干次传送，网络内所有的学校最终都能得到软件。

---

思路

1. 强连通分量分解，把强连通分量缩点。

2. 第一问就是最初把软件发给所有入度为0的点。任意一入度不为0的点，都可以由某一入度为0的出发得到。

3. 第二问就是添加几条边使整个图是一个强连通分量。

4. 统计入度为0和出度为0的点(缩点之后的点)的个数，第二问就是两者最大值。至于解释，对于得到的DAG图，考虑其中的出度为0的点和入度为0的点组成的点集V，将这些点相连，最多这需要max{ans1，ans2}条边，就能使整个图成为强连通分量。

5. 说说自己对缩点的理解，就是我们只关心点之间的到达情况，那么就可以把彼此可以到达的点用一个大点代替，内部互相可达，只考虑外部。

6. targan的思路：
   

---

代码

注意一下缩点之后统计入度出度的方法

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define _ ios_base::sync_with_stdio(0),cin.tie(0)
#define M(a,b) memset(a,b,sizeof(a))
using namespace std;

const int MAXN=1005;
const int oo=0x3f3f3f3f;
typedef __int64 LL;
const LL loo=4223372036854775807ll;
typedef long double LB;
const LL mod=1e9+7;
typedef long long LL;

struct Targan
{
    //sccno[i]为i所在的dfs块编号
    vector<int> G[MAXN];
    int pre[MAXN], lowlink[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
    stack<int> S;
    void init()
    {
        for(int i=0;i<MAXN;i++) G[i].clear();
        while(!S.empty()) S.pop();
    }
    void addedge(int a, int b)
    {
        G[a].push_back(b);
    }
    void dfs(int u)
    {
        pre[u]=lowlink[u]=++dfs_clock;
        S.push(u);
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i];
            if(!pre[v])
            {
                dfs(v);
                lowlink[u]=min(lowlink[u], lowlink[v]);
            }
            else if(!sccno[v])
            {
                lowlink[u]=min(lowlink[u], pre[v]);
            }
        }
        if(lowlink[u]==pre[u])
        {
            scc_cnt++;
            while(true)
            {
                int x=S.top();S.pop();
                sccno[x]=scc_cnt;
                if(x==u) break;
            }
        }
    }
    void find_scc(int n)
    {
        dfs_clock=scc_cnt=0;
        M(sccno, 0);M(pre, 0);
        for(int i=1;i<=n;i++)//注意修改取值范围
        {
            if(!pre[i]) dfs(i);
        }
    }
};
int indegree[MAXN], oudegree[MAXN];
int main()
{
    _;
    int n;
    Targan targan;
    while(cin>>n)
    {
        targan.init();
        M(indegree, 0), M(oudegree, 0);
        int maxindegree=0, maxoudegree=0;
        for(int i=1;i<=n;i++)
        {
            int m;
            while(cin>>m)
            {
                if(m==0) break;
                targan.G[i].push_back(m);
            }
        }
        targan.find_scc(n);
        if(targan.scc_cnt==1)
        {
            cout<<"1"<<endl<<"0"<<endl;
        }
        else
        {
            for(int i=1;i<=n;i++)
            {
                for(int j=0;j<targan.G[i].size();j++)
                {
                    if(targan.sccno[i]!=targan.sccno[targan.G[i][j]])
                    {
                        oudegree[targan.sccno[i]]=indegree[targan.sccno[targan.G[i][j]]]=1;
                    }
                }
            }
            int a, b;a=b=0;
            for(int i=1;i<=targan.scc_cnt;i++)
            {
                if(indegree[i]==0) a++;
                if(oudegree[i]==0) b++;
            }
            cout<<a<<endl<<max(a, b)<<endl;
        }
    }
    return 0;
}