POJ 1236 Network of Schools HDU 3836 Equivalent Sets 强连通分量+缩点 tarjan or kosaraju

1,POJ 1236

有一些学校连接到一个计算机网络，这些学校之间达成了一个协议：每个学校维护着一个学校列表，它向学校列表中的学校发布软件。注意，如果学校B在学校A的列表中，则A不一定在B的列表中。

任务A：计算为使得每个学校都能通过网络收到软件，至少需要准备多少份软件拷贝。

任务B：考虑一个更长远的任务，想确保给任意一个学校发放一个新的软件拷贝。该软件拷贝能发布到网络中的每个学校，为了达到这个目标，必须在列表中增加新成员。计算所需添加新成员的最小数目。

首先，缩点是很有必要的。

新生成的有向图是一个有向无环图。然后对于任务A，很容易想到，如果一些点有一个公共祖先，那么祖先有了软件，他们也都有了，所以求所有不同的公共祖先个数即可，而这些公共祖先的特征是入度为0。

任务B是添加尽量少的边，使图完全连通。图中有一片森林，有一些祖先结点和叶子结点，祖先结点特征是入度为0，叶子结点的特征是出度为0。很显然，只需要把一颗树的叶子结点轮流连接到相邻树的祖先结点上就能达到这个目标，但是当祖先结点多于叶子结点时，这是不够的，而此时，完全可以把所有的祖先结点相连而不去管叶子结点，最后B任务的答案就是祖先结点和叶子结点数量的较大值。

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define LOCA
#define MAXN 5005
#define INF 100000000
#define eps 1e-7
using namespace std;
struct Edge
{
    int v, next;
}edge[10 * MAXN], revedge[10 * MAXN];
int head[MAXN], revhead[MAXN], e, visited[MAXN];
int order[MAXN], cnt, id[MAXN], used[MAXN];
int uu[5 * MAXN], vv[5 * MAXN], out[MAXN], in[MAXN];
int a, b;
int n, m;
void init()
{
    e = 0;
    a = 0;
    b = 0;
    m = 0;
    memset(head, -1, sizeof(head));
    memset(revhead, -1, sizeof(revhead));
    memset(out, 0 , sizeof(out));
    memset(used, 0, sizeof(used));
    memset(in, 0, sizeof(in));
}
void insert(const int &x, const int &y)
{
    edge[e].v = y;
    edge[e].next = head[x];
    head[x] = e;
    revedge[e].v = x;
    revedge[e].next = revhead[y];
    revhead[y] = e;
    e++;
}
void readdata()
{
    for(int i = 1; i <= n; i++)
    {
        int x;
        while(scanf("%d", &x) != EOF && x)
        {
            uu[m] = i;
            vv[m++] = x;
            insert(i, x);
        }
    }
}
void dfs(int u)
{
    visited[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        if(!visited[v])
            dfs(v);
    }
    order[cnt++] = u;
}
void dfs_rev(int u)
{
    visited[u] = 1;
    id[u] = cnt;
    for(int i = revhead[u]; i != -1; i = revedge[i].next)
    {
        int v = revedge[i].v;
        if(!visited[v])
            dfs_rev(v);
    }
}
void Kosaraju()
{
    init();
    readdata();
    memset(visited, 0, sizeof(visited));
    cnt = 0;
    for(int i = 1; i <= n; i++)
    {
        if(!visited[i])
            dfs(i);
    }
    memset(visited, 0, sizeof(visited));
    cnt = 0;
    for(int i = n - 1; i >= 0; i--)
    {
        if(!visited[order[i]])
        {
            cnt++;
            dfs_rev(order[i]);
        }
    }
    for(int i = 0; i < m; i++)
    {
        int u = id[uu[i]];
        int v = id[vv[i]];
        if(u != v) {out[u]++; in[v]++;}
    }
    for(int i = 1; i <= cnt; i++)
    {
        if(out[i] == 0)
            b++;
        if(in[i] == 0)
            a++;
    }
}
int main()
{
    while(scanf("%d", &n) != EOF)
    {
        Kosaraju();
        b = max(a, b);
        if(cnt == 1) b = 0;
        printf("%d\n%d\n", a, b);
    }
    return 0;
}

tarjan版

#include <iostream>
#include <map>
#include <cstdio>
#include <stack>
#include <cstring>
#include <algorithm>
#define MAXN 205
#define MAXM 50005
#define INF 1000000000
using namespace std;
int n, m;
int scc;//强连通分量
int index;//每个节点的dfs访问次序编号
int dfn[MAXN];//标记结点i的dfs访问次序
int low[MAXN];//记录节点u或u的子树中的所有节点的最小标号
int fa[MAXN];//属于哪个分支
bool instack[MAXN];//是否在栈中
int in[MAXN], head[MAXN], e;
int out[MAXN];//出度
stack <int>s;
struct Edge
{
    int v, next;
}edge[MAXM];
void insert(int x, int y)
{
    edge[e].v = y;
    edge[e].next = head[x];
    head[x] = e++;
}
void tarjan(int u)
{
    dfn[u] = low[u] = ++index;
    s.push(u);
    instack[u] = true;
    for (int j = head[u]; j != -1; j = edge[j].next)
    {
        int v = edge[j].v;
        if(dfn[v] == 0)//未曾访问过
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instack[v])
            low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        scc++;
        while(1)
        {
            int tmp = s.top();
            s.pop();
            instack[tmp] = 0;
            fa[tmp] = scc;
            if(tmp == u) break;
        }
    }
}

void solve()
{
    scc = index = 0;
    memset(dfn, 0, sizeof(dfn));
    for (int i = 1;i <= n; i++)
    {
        if (!dfn[i])
            tarjan(i);
    }

    memset(in, 0, sizeof(in));
    memset(out, 0, sizeof(out));

    for (int i = 1;i <= n; i++)
    {
        for(int j = head[i]; j != -1; j = edge[j].next)
        {
            int u = fa[i];
            int v = fa[edge[j].v];
            if(u != v)
            {
                out[u]++;
                in[v]++;
            }
        }
    }
    int outn = 0;
    int inn = 0;
    for(int i = 1;i <= scc; i++)
    {
        if(in[i] == 0) inn++;
        if(out[i] == 0) outn++;
    }
    printf("%d\n", inn);
    if(scc == 1) {printf("0\n"); return;}
    printf("%d\n", max(outn, inn));
}

int main()
{
    scanf("%d", &n);
    e = 0;
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= n; i++)
    {
        int a;
        while(scanf("%d", &a) && a)
            insert(i, a);
    }
    solve();
    return 0;
}

2,HDU 383

题意很明确。给出了n个集合，然后用最少的步数证明他们是相等的。

首先，对于两个集合，如果互为对方的子集，则两个集合是相等的。

然后，仔细想，可以发现，已经证明相等的集合可以看成一个集合，就相当于缩点，最后要达到的目标是，添加一些边，使整个图是强连通的。

那么就跟POJ 1236是一摸一样的了。