poj 1236(强连通分量分解模板题)

传送门

题意：

　　N(2<N<100)个学校之间有单向的网络，每个学校得到一套软件后，可以通过单向网络向周边的学校传输。

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

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

从题意中抽象出的算法模型：

　　给定一个有向图，求：

　　1) 至少要选几个顶点，才能做到从这些顶点出发，可以到达全部顶点。

　　2) 至少要加多少条边，才能使得从任何一个顶点出发，都能到达全部顶点。

题解：

　　1. 求出所有强连通分量

　　2. 每个强连通分量缩成一点，则形成一个有向无环图DAG。

　　3. DAG上面有多少个入度为0的顶点，问题1的答案就是多少。

　　在DAG上要加几条边，才能使得DAG变成强连通的，问题2的答案就是多少。

　　加边的方法：

　　要为每个入度为0的点添加入边，为每个出度为0的点添加出边。

　　假定有 n 个入度为0的点，m个出度为0的点，如何加边？

　　把所有入度为0的点编号 0,1,2,3,4 ....N -1

　　每次为一个编号为 i 的入度为0的点到出度为0的点，添加一条出边，这需要加n条边。

　　若 m <= n，则

　　加了这n条边后，已经没有入度0点，则问题解决，一共加了 n 条边

　　若 m > n，则还有m-n个入度0点，则从这些点以外任取一点，和这些点都连上边，即可，这还需加m-n条边。

　　所以，max(m,n)就是第二个问题的解

　　此外：当只有一个强连通分支的时候，就是缩点后只有一个点，虽然入度出度为0的都有一个，但是实际上不需要增加边了，所以答案是0。

以上解析来源于bin巨%%%%%%

AC代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define pb push_back
 #define mem(a,b) memset(a,b,sizeof a)
 const int maxn=;//最大的节点个数，一般是 1e5 级别的
 
 int scc[maxn];//所属强连通分量的拓扑排序
 bool vis[maxn];//vis[u] : dfs中判断节点u是否被访问过
 vector<int >vs;//后序遍历顺序的顶点列表
 vector<int >edge[maxn],redge[maxn];//边、反边
 
 void addEdge(int u,int v)
 {
     edge[u].pb(v);
     redge[v].pb(u);
 }
 void Dfs(int u)//第一次dfs，后序遍历标记，越靠近叶子结点标号越小
 {
     vis[u]=true;
     for(int i=;i < edge[u].size();++i)
     {
         int to=edge[u][i];
         if(!vis[to])
             Dfs(to);
     }
     vs.pb(u);
 }
 void rDfs(int u,int sccId)//反向dfs，利用反向图，求出强连通分量个数
 {
     vis[u]=true;
     scc[u]=sccId;
     for(int i=;i < redge[u].size();++i)
     {
         int to=redge[u][i];
         if(!vis[to])
             rDfs(to,sccId);
     }
 }
 int Scc(int maxV)
 {
     mem(vis,false);
     vs.clear();
     for(int i=;i <= maxV;++i)
         if(!vis[i])
             Dfs(i);
     mem(vis,false);
     int sccId=;//DAG节点个数
     for(int i=vs.size()-;i >= ;--i)
     {
         int to=vs[i];
         if(!vis[to])
         {
             sccId++;
             rDfs(to,sccId);
         }
     }
     return sccId;//返回强连通分量的个数
 }
 int main()
 {
     int N;
     scanf("%d",&N);
     for(int i=;i <= N;++i)
     {
         int v;
         while(scanf("%d",&v) && v)
             addEdge(i,v);
     }
     int sccId=Scc(N);
     int in[maxn];
     int out[maxn];
     mem(in,);
     mem(out,);
 
     for(int i=;i <= N;++i)
         for(int j=;j < edge[i].size();++j)
         {
             int to=edge[i][j];
             if(scc[i] != scc[to])
                 out[scc[i]]++,in[scc[to]]++;
         }
     int zeroIn=;
     int zeroOut=;
     for(int i=;i <= sccId;++i)
     {
         zeroIn += (in[i] ==  ? :);
         zeroOut += (out[i] ==  ? :);
     }
     printf("%d\n",zeroIn);
     if(sccId == )
         printf("0\n");
     else
         printf("%d\n",max(zeroIn,zeroOut));
 }

---

分割线2019.4.27

半年后的我，代码风格：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define pb(x) push_back(x)
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=+;
 
 int n;
 int num;
 int head[maxn];
 struct Edge
 {
     int to;
     int next;
 }G[maxn*maxn<<];
 void addEdge(int u,int v)
 {
     G[num]={v,head[u]};
     head[u]=num++;
 }
 struct SCC
 {
     int col[maxn];
     int in[maxn];
     int out[maxn];
     bool vis[maxn];
     vector<int >vs;
     void DFS(int u)
     {
         vis[u]=true;
         for(int i=head[u];~i;i=G[i].next)
         {
             int v=G[i].to;
             if(vis[v] || (i&))
                 continue;
             DFS(v);
         }
         vs.pb(u);
     }
     void RDFS(int u,int k)
     {
         col[u]=k;
         vis[u]=true;
         for(int i=head[u];~i;i=G[i].next)
         {
             int v=G[i].to;
             if(vis[v] || !(i&))
                 continue;
             RDFS(v,k);
         }
     }
     int scc()
     {
         mem(vis,false);
         vs.clear();
         for(int i=;i <= n;++i)
             if(!vis[i])
                 DFS(i);
 
         int k=;
         mem(vis,false);
         for(int i=vs.size()-;i >= ;--i)
             if(!vis[vs[i]])
                 RDFS(vs[i],++k);
 
         mem(in,);
         mem(out,);
         for(int u=;u <= n;++u)
         {
             for(int i=head[u];~i;i=G[i].next)
             {
                 int v=G[i].to;
                 if(i&)
                     continue;
                 if(col[u] != col[v])
                 {
                     out[col[u]]++;///col[u]:出度++
                     in[col[v]]++;///col[v]:入度++
                 }
             }
         }
         return k;
     }
 }_scc;
 void Solve()
 {
     int k=_scc.scc();
 
     int zeroIn=;
     int zeroOut=;
     for(int i=;i <= k;++i)
     {
         if(!_scc.in[i])
             zeroIn++;
         if(!_scc.out[i])
             zeroOut++;
     }
     printf("%d\n%d\n",zeroIn,k ==  ? :max(zeroIn,zeroOut));
 }
 void Init()
 {
     num=;
     mem(head,-);
 }
 int main()
 {
 //    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
     while(~scanf("%d",&n))
     {
         Init();
         for(int i=;i <= n;++i)
         {
             int v;
             while(scanf("%d",&v) && v)
             {
                 addEdge(i,v);
                 addEdge(v,i);
             }
         }
         Solve();
     }
     return ;
 }