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

原创 2012年03月23日 22:25:32

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是一摸一样的了。

版权声明:本文为博主原创文章,未经博主允许不得转载。

poj1236 Network of Schools--Kosaraju算法 & 缩点 & 强连通分量

原题链接:http://poj.org/problem?id=1236 题意:n个学校,给定n行,第i行代表i学校到其他学校是可传输的,单向。问题1:初始至少需要向多少个学校发放软件,使得网...
  • LaoJiu_
  • LaoJiu_
  • 2016年09月10日 10:01
  • 523

poj1236 Network of Schools ,有向图求强连通分量(Tarjan算法),缩点

题目链接: 点击打开链接 题意:  给定一个有向图,求: 1) 至少要选几个顶点,才能做到从这些顶点出发,可以到达全部顶点 2) 至少要加多少条边,才能使得从任何一个顶点出发,都能到达全部顶点  ...
  • yew1eb
  • yew1eb
  • 2014年08月04日 14:31
  • 1825

poj1236Network of Schools_强连通分量缩点(tarjan算法解决)

poj1236题目链接 题目大意:有N个学校,从每个学校都能从一个单向网络到另外一个学校,两个问题 1:初始至少需要向多少个学校发放软件,使得网络内所有的学校最终都能得到软件。 2:至少需要添加...

Network of Schools POJ - 1236 tarjan强连通分量缩点

A number of schools are connected to a computer network. Agreements have been developed among those ...

POJ 1236 Network of Schools【强连通分量分解&&缩点||tarjan&&缩点】

Network of Schools Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 1423...
  • wyjwyl
  • wyjwyl
  • 2016年03月01日 16:21
  • 177

HDU 3836 Equivalent Sets(强连通分量 Tarjan缩点)

Tarjan求强连通分量详解在前一篇文章 把一个有向图变为强连通分量至少要加几条边? Tarjan缩点后,设a为入度为0的点数,b为出度为0的点数,答案max(a,b)。 注意:如果图本...

POJ 1236 Network of Schools 强连通分量 kosaraju

Network of Schools Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 16735 Acce...

POJ-1236 Network of Schools (强连通分量[Tarjan])

首先又得了解到一个定理:有向无环图中所有入度不为0的点,一定可以由某个入度为0的点出发可达。(由于无环,所以从任何入度不为0的点往回走,必然终止于一个入度为0的点) 则可以处理出所有的强连通分量,并将...

【POJ 1236】Network of Schools(强连通分量_tarjan)

问题描述 A number of schools are connected to a computer network. Agreements have been developed among ...

POJ1236 Network of Schools(强连通分量:Tarjan算法)

题意: 学校之间有网络系统,通过网络可以从一个学校定向的传递文件给另一个学校。现在问最少给几个学校传递文件使所有学校都能收到?最少添加几天网络边可以使整个网络连通? 要点: 就是一个基本的强连通...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:POJ 1236 Network of Schools HDU 3836 Equivalent Sets 强连通分量+缩点 tarjan or kosaraju
举报原因:
原因补充:

(最多只允许输入30个字)