强连通图 ( Tarjan，邻接矩阵 )——Network of Schools ( POJ 1236 )

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

• 分析：
  N个学校之间有单向的网络，每个学校得到一套软件后，可以通过单向网络向周边学校发送该软件。
  Q1：至少需要给多少个学校发放软件，才能使得所有的学校最终能得到软件。
  Q2：至少需要增加几条传输路线，使得任意向一个学校发放软件后，经过若干次传输，所有学校都能得到软件。

• 题解：
  找强连通分量，缩点。记f[i]为缩完点后的新图中各点入度，g[i]为出度，ans1为f[i]==0的点的数目，ans2为g[i]==0的点的数目，则第一问为ans1，第二问则为max{ans1，ans2}。

  至于第二问的解释，对于得到的DAG图，考虑其中的出度为0的点和入度为0的点组成的点集V，将这些点相连，最多这需要max{ans1，ans2}条边，就能使整个图成为强连通分量。

  但是这个结论的前提是DAG图是连通的情况下才成立。如果DAG图有多个连通分量，则还要考虑将多个连通分量合并的所需代价。不过这道题保证了只有一个连通分量。

• 代码：

1.建图：（因为该题点数较少，所以可以考虑邻接矩阵建图）

int map[MAXN][MAXN];
for(i= 1; i <= n; i++)
{
    while(scanf("%d", &temp) && temp)
    {
        map[i][temp] = 1;
    }
}

2.tarjan计算出强连通分量

#define MAXN 110
#define INF 0x3f3f3f3f
int n;
int map[MAXN][MAXN];
int low[MAXN];
int dfn[MAXN];
int stack[MAXN], head;
int instack[MAXN];
int belong[MAXN];
int Index, cnt;

void tarjan(int x)
{
    int i, a;
    low[x] = dfn[x] = Index; // 刚搜到一个节点时low = dfn
    Index++;
    stack[++head] = x; // 将该节点入栈
    instack[x] = 1; // 将入栈标记设置为1
    for(i = 1; i <= n; i++) // 遍历入栈节点的边
    {
        if(!map[x][i]) // 如果两点之间没有边
            continue; // 不用管它
        if(dfn[i] == -1) // 如果新搜索到的节点是从未被搜索过
        {
            tarjan(i); // 那自然就得搜索这个节点
            low[x] = min(low[x], low[i]); // 回溯的时候改变当前节点的low值
        }
        else if(instack[i]) // 如果新搜索到的节点已经被搜索过而且现在在栈中
        {
            low[x] = min(low[x], dfn[i]); // 更新当前节点的low值，这里的意思是两个节点之间有一条可达边，而前面
        }                                 // 而前面节点已经在栈中，那么后面的节点就可能和前面的节点在一个联通分量中
    }

    if(low[x] == dfn[x]) // 最终退回来的时候 low == dfn ， 没有节点能将根节点更新，那
    {                   // low == dfn 的节点必然就是根节点
        int temp;
        while(1) // 一直出栈到此节点， 这些元素是一个强联通分量
        {
            temp = stack[head--]; // 弹出栈元素
            belong[temp] = cnt; // 为了方便计算，将强联通分量进行标记
            instack[temp] = 0; // 将栈内标记置为0
            if(temp == x)     // 一直弹到x出现为止
                break;
        }
        cnt++;
    }
}

• 输出：
  找除入度为0和出度为0的强连通分量的数量。

int in[MAXN];
int out[MAXN];
void solve()
{
    int i, j;
    int t1, t2;
    while(scanf("%d", &n) != EOF) //
    {
        init(); // 初始化
        for(i = 1; i <= n; i++) //
            if(dfn[i] == -1) // 如果某点没被访问过，则对其进行tarjan
                tarjan(i);          // tarjan的成果是得到了一个belong数组，记录每个节点分别属于哪个强联通分量
        for(i = 1; i <= n; i++) // 遍历每条边，找到缩点之后的边
        {
            for(j = 1;j <= n; j++)
            {
                if(map[i][j] && belong[i] != belong[j]) // 两点之间有边，但不是属于一个强联通分量的边
                {
                    out[belong[i]]++; // 缩点后的点入度+1
                    in[belong[j]]++;// 缩点后的点出度+1
                }
            }
        }

        t1 = 0, t2 = 0;

        for(i = 1; i < cnt; i++)
        {
            if(in[i] == 0)
                t1++;
            if(out[i] == 0)
                t2++;
        }
        if(cnt == 2)
            printf("1\n0\n");
        else
            printf("%d\n%d\n", t1, max(t1, t2));
    }
}

• 参考代码：

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

#define MAXN 110
#define INF 0x3f3f3f3f
int n;
int map[MAXN][MAXN];
int low[MAXN];
int dfn[MAXN];
int stack[MAXN], head;
int instack[MAXN];
int belong[MAXN];
int in[MAXN];
int out[MAXN];
int Index, cnt;

int min(int a, int b)
{
    return a < b ? a : b;
}

int max(int a, int b)
{
    return a > b ? a : b;
}

void init()
{
    int i, j;
    int temp;
    memset(map, 0, sizeof(map));
    memset(dfn, -1, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(instack, 0, sizeof(instack));
    Index = cnt = 1;
    head = 0;
    for(i= 1; i <= n; i++)
    {
        while(scanf("%d", &temp) && temp)
        {
            map[i][temp] = 1;
        }
    }
}

void tarjan(int x)
{
    int i, a;
    low[x] = dfn[x] = Index; // 刚搜到一个节点时low = dfn
    Index++;
    stack[++head] = x; // 将该节点入栈
    instack[x] = 1; // 将入栈标记设置为1
    for(i = 1; i <= n; i++) // 遍历入栈节点的边
    {
        if(!map[x][i]) // 如果两点之间没有边
            continue; // 不用管它
        if(dfn[i] == -1) // 如果新搜索到的节点是从未被搜索过
        {
            tarjan(i); // 那自然就得搜索这个节点
            low[x] = min(low[x], low[i]); // 回溯的时候改变当前节点的low值
        }
        else if(instack[i]) // 如果新搜索到的节点已经被搜索过而且现在在栈中
        {
            low[x] = min(low[x], dfn[i]); // 更新当前节点的low值，这里的意思是两个节点之间有一条可达边，而前面
        }                                 // 而前面节点已经在栈中，那么后面的节点就可能和前面的节点在一个联通分量中
    }

    if(low[x] == dfn[x]) // 最终退回来的时候 low == dfn ， 没有节点能将根节点更新，那
    {                   // low == dfn 的节点必然就是根节点
        int temp;
        while(1) // 一直出栈到此节点， 这些元素是一个强联通分量
        {
            temp = stack[head--]; // 弹出栈元素
            belong[temp] = cnt; // 为了方便计算，将强联通分量进行标记
            instack[temp] = 0; // 将栈内标记置为0
            if(temp == x)     // 一直弹到x出现为止
                break;
        }
        cnt++;
    }
}


void solve()
{
    int i, j;
    int t1, t2;
    while(scanf("%d", &n) != EOF) //
    {
        init(); // 初始化
        for(i = 1; i <= n; i++) //
            if(dfn[i] == -1) // 如果某点没被访问过，则对其进行tarjan
                tarjan(i);          // tarjan的成果是得到了一个belong数组，记录每个节点分别属于哪个强联通分量
        for(i = 1; i <= n; i++) // 遍历每条边，找到缩点之后的边
        {
            for(j = 1;j <= n; j++)
            {
                if(map[i][j] && belong[i] != belong[j]) // 两点之间有边，但不是属于一个强联通分量的边
                {
                    out[belong[i]]++; // 缩点后的点入度+1
                    in[belong[j]]++;// 缩点后的点出度+1
                }
            }
        }

        t1 = 0, t2 = 0;

        for(i = 1; i < cnt; i++)
        {
            if(in[i] == 0)
                t1++;
            if(out[i] == 0)
                t2++;
        }
        if(cnt == 2)
            printf("1\n0\n");
        else
            printf("%d\n%d\n", t1, max(t1, t2));
    }
}

int main()
{
    solve();
    return 0;
}