Network of Schools——强连通分量缩点

题目链接

题意：

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

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

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

转化一下即

给定一个有向图，求：

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

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

题解：

强连通分量缩点求入度为0的个数和出度为0的分量个数

问题1是求缩点后，新建图，入度为0的点的个数

问题2是求缩点后，新建图，入度为0的和出度为0的点的个数的最大值即使图中没有入度为0和出度为0的点

注意： 当只有一个强连通分支的时候，就是缩点后只有一个点，虽然入度出度为0的都有一个，但是实际上不需要增加清单的项了，所以答案是1，0；

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include<vector>
#include <map>
using namespace std;

const int maxn = 5010;//点数
const int maxm = 20010;//边数，因为是无向图，所以这个值要*2

struct Edge
{
    int to,next;
    bool cut;//是否是桥标记
} edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn],Stack[maxn],belong[maxn];//belong数组的值是1~scc
int Index,top;
int scc;//边双连通块数/强连通分量的个数
bool Instack[maxn];
int bridge;//桥的数目
bool cut[maxn];// 是否为割点
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].cut=false;
    head[u] = tot++;
}
void Tarjan(int u,int pre)
{
    int v;
    low[u] = dfn[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son=0;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre)continue;
        if( !dfn[v] )
        {
            son++;
            Tarjan(v,u);
            if( low[u] > low[v] )low[u] = low[v];
            if(low[v] > dfn[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;
            }
            if(u == pre && son > 1)cut[u] = true;
            if(u != pre && low[v] >= dfn[u])cut[u] = true;

        }
        else if( Instack[v] && low[u] > dfn[v] )
            low[u] = dfn[v];
    }

    if(low[u] == dfn[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            belong[v] = scc;
        }
        while( v!=u );
    }

}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
int vis[maxn][2];
int in[maxn],out[maxn];
void solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(Instack,false,sizeof(Instack));
    memset(cut,0,sizeof cut);
    Index = top = scc = 0;
    bridge = 0;
    for(int i = 1; i <= n; i++)
        if(!dfn[i])
            Tarjan(i,i);
}
int main()
{
    int n;
    scanf("%d",&n);
    init();
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int x;
        while(scanf("%d",&x) && x)
        {
            addedge(i,x);
            vis[++cnt][0]=i;
            vis[cnt][1]=x;
        }
    }
    solve(n);

    for(int i=1;i<=cnt;i++)
    {
        if(belong[vis[i][0]]!=belong[vis[i][1]])
        {
            out[belong[vis[i][0]]]++;
            in[belong[vis[i][1]]]++;
        }
    }
    int ans1=0,ans2=0;
    for(int i=1;i<=scc;i++)
    {
        if(in[i]==0)ans1++;
        if(out[i]==0)ans2++;
    }
    if(scc==1)printf("1\n0\n");
    else printf("%d\n%d\n",ans1,max(ans1,ans2));
    return 0;
}

View Code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef  long long ll;
const int inf = 1<<30;
const int mod=1e9;
const int maxn = 20010;//点数
const int maxm = 50010;//边数
struct node
{
    int to,next;
} edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn],Stack[maxn],belong[maxn];//belong 数组的值是 1~scc
int Index,top;
int scc;//强连通分量的个数
bool Instack[maxn];
int num[maxn];//各个强连通分量包含点的个数，数组编号 1 ∼ scc
//num 数组不一定需要，结合实际情况
int vis[maxn][2];
int in[maxn],out[maxn];
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void Tarjan(int u)
{
    int v;
    low[u] = dfn[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if( !dfn[v] )
        {
            Tarjan(v);
            if( low[u] > low[v] )low[u] = low[v];
        }
        else if(Instack[v] && low[u] > dfn[v])
            low[u] = dfn[v];
    }
    if(low[u] == dfn[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            belong[v] = scc;
            num[scc]++;
        }
        while( v != u);
    }
}
void solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));
    Index = scc = top = 0;
    for(int i = 1; i <= n; i++)
        if(!dfn[i])
            Tarjan(i);
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

int main()
{
    int n;
    scanf("%d",&n);
    init();
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int x;
        while(scanf("%d",&x) && x)
        {
            addedge(i,x);
            vis[++cnt][0]=i;
            vis[cnt][1]=x;
        }
    }
    solve(n);

    for(int i=1;i<=cnt;i++)
    {
        if(belong[vis[i][0]]!=belong[vis[i][1]])
        {
            out[belong[vis[i][0]]]++;
            in[belong[vis[i][1]]]++;
        }
    }
    int ans1=0,ans2=0;
    for(int i=1;i<=scc;i++)
    {
        if(in[i]==0)ans1++;
        if(out[i]==0)ans2++;
    }
    if(scc==1)printf("1\n0\n");
    else printf("%d\n%d\n",ans1,max(ans1,ans2));
    return 0;
}

kuangbin

原文地址：https://www.cnblogs.com/j666/p/11630480.html