POJ1236_A - Network of Schools _强连通分量::Tarjan算法

题意

有向图上有 N 个点，若干有向边。

第一问：至少给几个点传递信息，才能保证信息传遍整个图。

第二问：至少添加几条边，才能使任意选择点，都能传遍整个图。

思路

强连通分量的裸题。

强连通分量内的任意一点收到消息，内部其他各点必定都能收到消息。因此，可以把每个强连通分量缩成一个点。只需要考察入度为 0 的强连通分量的个数，就是第一问的答案。

对于第二问，是把图连接成一个强连通分量，同样可以在缩点后的图中操作。这里的做法是统计图中入度为0、出度为0的强连通分量的个数，取较大值即为第二问的答案。

原图中各ssc之间不会成环，如果成环的话就是一个ssc了。要使整个图强连通，至少要使所有分量的入度和出度都为0。这样也是必定存在合法方案的。

本题中原图只有一个强连通分量的情况需要特判。

Tarjan算法

Tarjan算法是基于bfs查找强连通分量的方法。

每个点赋予三个附加属性。时间戳，发现该点的时间；根，该节点所在强连通分量中的最小时间戳；是否在栈中标记。

从任意一点出发，对图进行bfs。

每进入一个点，标记时间戳，将根置为本身，压栈。然后搜索与它相连的其他各点。如果没有到达过，则进入那个点。如果已经到达过，并且那个点现在仍在栈中，说明这两个点在同一个强连通分量里。比较当前点的根和那个点的时间戳，如果那个点的时间戳较小，则把根改成那个点的时间戳。即这两个点并入了同一个强连通分量。

沿bfs路径返回的时候，首先更新根节点（因为出现环表示发现了强连通分量，而从下网上返回的时候靠下的点的根是真的根），并检查每个点的时间戳和根是否相等。如果相等，说明当前点就是它所在强连通分量的根。而此时的栈中，比它后进栈的元素都在这个强连通分量中。更新ssc个数，将这些点连通当前点加入一个ssc中，并全部弹栈。

题目链接

http://poj.org/problem?id=1236

AC代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>

using namespace std;

const int maxn = 100 + 10;

int N;
int In[maxn], Out[maxn];

/***************************Tarjan算法模板***************************/
vector<int> G[maxn];
int Mark[maxn], Root[maxn], Stack[maxn];                                //时间戳，根(当前分量中时间戳最小的节点)，栈
bool Instack[maxn];                                                     //是否在栈中标记
int Ssc[maxn];                                                          //每个节点所在的强连通分量的编号
int Index, Ssc_n, Top;                                                  //搜索时用的时间戳，强连通分量总数，栈顶指针

void Tarjan(int u)                                                      //u 当前搜索到的点
{
Mark[u] = Root[u] = ++ Index;                                       //每找到一个点，对时间戳和根初始化
Stack[Top ++] = u;                                                  //压栈
Instack[u] = true;                                                  //在栈中标记

int v;

for(int i= 0; i< G[u].size(); i++)                                  //向下搜索
{
v = G[u][i];
if(Mark[v] == 0)                                                //没到过的点
{
Tarjan(v);                                                  //先向下搜索
if(Root[u] > Root[v]) Root[u] = Root[v];
c8cd
//更新根
}
else if(Instack[v] && Root[u] > Mark[v]) Root[u] = Mark[v];     //到过的点且点仍在栈中，试着看这个点能不能成为根
}
/*对当前点的搜索结束*/
if(Mark[u] == Root[u])                                              //当前点本身时根
{
Ssc_n ++;                                                       //更新强连通分量数

do{                                                             //栈中比它后入栈的元素在以它为根的强连通分量中
v = Stack[-- Top];
Instack[v] = false;
Ssc[v] = Ssc_n;
}while(v != u);                                                 //直到它自己
}
}

void SSC()
{
memset(Mark, 0, sizeof Mark);                                       //初始化时间戳和栈内标记
memset(Instack, false, sizeof Instack);
Index = Ssc_n = Top = 0;                                            //初始化时间戳，强连通分量数，栈顶指针

for(int i= 1; i<= N; i++)                                           //保证图上所有点都访问到
if(Mark[i] == 0) Tarjan(i);
}
/***************************Tarjan算法模板***************************/

int main()
{
//freopen("in.txt", "r", stdin);

scanf("%d", &N);
for(int i= 1; i<= N; i++)
{
int x;
while(scanf("%d", &x), x)
G[i].push_back(x);
}

SSC();

if(Ssc_n == 1)                                                      //只有一个强连通分量的情况
{
cout << "1\n0\n";
return 0;
}

memset(In, 0, sizeof In);                                           //求每个强连通分量的入度和出度
memset(Out, 0, sizeof Out);
for(int u= 1; u<= N; u++)
{
for(int i= 0; i< G[u].size(); i++)
{
int v = G[u][i];
if(Ssc[u] != Ssc[v])
Out[Ssc[u]] ++, In[Ssc[v]] ++;
}
}

int S1 = 0, S2 = 0;                                                 //找入度为0、出度为0的点的数目
for(int i= 1; i<= Ssc_n; i++)
{
if(In[i] == 0) S1 ++;
if(Out[i] == 0) S2 ++;
}

cout << S1 << endl << max(S1, S2) << endl;

return 0;
}