【强连通分量】

有向图的强连通分量

一.定义

         给定一张有向图。若对于任意两个节点x，y 既存在从x->y的路径，也存在从y->x的路径，则称该有向图为“强连通图”。

          有向图的极大连通子图被称为强连通分量。

二.强连通分量的求法。

          1.Tarjan算法

                    基于 dfs 的一种算法，每一个强连通分量为其搜索树的一棵子树，并且需要用到 栈 的数据结构。

                    tarjan 中两个重要的数组  dfn[] （时间戳，搜索时的序号） ， low[] （表示当前能回溯到的最小的时间戳）， 初始化  dfn[] = low[] = ++ cnt;

                    运算过程：

                                （1）. main 函数里面用 for 循环 查找 ，若dfn[]为0，则进行 tarjan 算法。

                                （2）.  设 v[] 数组表示是否进栈，设 栈 sta[]；

                                （3）. 对于每个搜索的 x ，对其相连的边进行搜索，若没有，递归运行，若已经入栈，说明形成了 环 ，更新 low 值；、

                                （4）. 不断深搜的过程中，若出边的遍历完了，进行回溯，不断比较 low 值，取最小值 ， 若dfn[] == low[] ,则找到了 一个强连通分量的根，然后对栈进行弹出操作，直到x 被弹出栈；

code

inline void tarjan(int x){
    dfn[x]=++ind;
    low[x]=ind;
    s[++top]=x;
    v[x]=1;
    for(int i=head[x];i;i=next[i]){
        int y=ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[y],low[x]);
        }
        else if(v[y]==1){
            low[x]=min(low[x],dfn[y]);
        }
    }
    if(low[x]==dfn[x]){
        int y;
        do{
            y=s[top--];
            v[y]=0;
        }while(y != x);
    }
}    

              2.Kosaraju 算法

                           算法流程：

                                         （1）存图时需要再存一个反图  ；

                                         （2） 先在原图上 进行 dfs ，不断访问节点，在回溯前进行后序遍历标号

                                     （3） 第二次进行dfs 时，需用到反图，以标号最大的顶点为起点进行遍历，遍历完后，由dfs 遍历过的顶点集合就是一个强连通分量。

                                       p.s: 要对集合进行分类标记，每找到一个新的起点就要对 标记值进行自增；

code           

int k=0;
inline void dfs(int x){
    v[x]=1;
    for(int i=0;i<g[x].size();i++){
        if(!v[g[x][i]]) dfs(g[x][i]); 
    }
    vs.push_back(x);
}
inline void rdfs(int x){
    v[x]=1;
    fa[x]=k;
    for(int i=0;i<rg[x].size();i++){
        if(!v[rg[x][i]]) rdfs(rg[x][i]);
     } 
}
inline void work(){
    for(int i=1;i<=n;i++){
        if(!v[i]) dfs(i);
    }
    memset(v,0,sizeof(v));
    for(int i=vs.size()-1;i>=0;i--){
        if(!v[vs[i]]) {
            k++;
            rdfs(vs[i]);
        }
    }
}

 三.例题e.g.

No.1.受欢迎的牛[HAOI2006]（来源：洛谷）

题目描述

每头奶牛都梦想成为牛棚里的明星。被所有奶牛喜欢的奶牛就是一头明星奶牛。所有奶牛都是自恋狂，每头奶牛总是喜欢自己的。奶牛之间的“喜欢”是可以传递的——如果A喜欢B，B喜欢C，那么A也喜欢C。牛栏里共有N 头奶牛，给定一些奶牛之间的爱慕关系，请你算出有多少头奶牛可以当明星。

输入格式

第一行：两个用空格分开的整数：N和M

第二行到第M + 1行：每行两个用空格分开的整数：A和B，表示A喜欢B

输出格式

第一行：单独一个整数，表示明星奶牛的数量

输入输出样例

输入 #1

3 3
1 2
2 1
2 3

输出 #1

1

说明/提示

只有 3 号奶牛可以做明星

【数据范围】

10%的数据N<=20, M<=50
30%的数据N<=1000,M<=20000
70%的数据N<=5000,M<=50000
100%的数据N<=10000,M<=50000

 

 思路：

        看图

          可以得出， b,c,d   为强连通分量，可知，分量中任意一个点被喜欢，则分量中所有点都会被喜欢，所以将图中的所有强连通分量看作一个点，则图变成一个有向无环图，且成为明星   的牛一定是出度为零的点 。

code          

#include <bits/stdc++.h>
using namespace std;

const int N=50001 * 2;
int n,m,k=0;
int head[N],next[N],ver[N],tot;
int f[N],d[N],out[N],an[N];

int find(){
    int ans=0;
    for(int i=1;i<=k;i++){
        for(int j=head[f[i]];j;j=next[j]){
            int y=ver[j];
            if(!d[y]) ans++;
        }
    }
    return ans;
}

inline void add(int x,int y){
    ver[++tot]=y;
    next[tot]=head[x];
    head[x]=tot;
}

int s[N],top=0;
int v[N];
int dfn[N],low[N],ind=0;
int belong[N],cnt=0;

inline void tarjan(int x){
    dfn[x]=++ind;
    low[x]=ind;
    s[++top]=x;
    v[x]=1;
    for(int i=head[x];i;i=next[i]){
        int y=ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[y],low[x]);
        }
        else if(v[y]==1){
            low[x]=min(low[x],dfn[y]);
        }
    }
    if(low[x]==dfn[x]){
        ++cnt;
        int y;
        do{
            y=s[top--];
            v[y]=0;
            f[++k]=y;
            d[y]=1;
            an[cnt]++;
        }while(y!=x);
        out[cnt]=find();
        k=0;
        memset(d,0,sizeof(d));
    }
}    

inline int read(){//快读
    int ans=0,f=1;
    char s=getchar();
    while(!isdigit(s)) f*=(s=='-')? -1:1,s=getchar();
    do ans=(ans<<1)+(ans<<3)+(s^48),s=getchar();
    while(isdigit(s));
    return ans*f;
}

int main(){
    n=read(),m=read();
    for(int i=1;i<=m;i++){
        int a=read(),b=read();
        add(a,b);
    }
    for(int i=1;i<=n;i++)
       if(!dfn[i]) tarjan(i);
    int s=0,ans;
    for(int i=1;i<=cnt;i++){
        if(!out[i]) s++,ans=i;
    }
    if(s==1) printf("%d",an[ans]);
    else printf("0");
    return 0;
} 

 No.2  稳定婚姻（来源：洛谷）

题目描述

我国的离婚率连续7年上升，今年的头两季，平均每天有近5000对夫妇离婚，大城市的离婚率上升最快，有研究婚姻问题的专家认为，是与简化离婚手续有关。

25岁的姗姗和男友谈恋爱半年就结婚，结婚不到两个月就离婚，是典型的“闪婚闪离”例子，而离婚的导火线是两个人争玩电脑游戏，丈夫一气之下，把电脑炸烂。

有社会工作者就表示，80后求助个案越来越多，有些是与父母过多干预有关。而根据民政部的统计，中国离婚五大城市首位是北京，其次是上海、深圳，广州和厦门，那么到底是什么原因导致我国成为离婚大国呢?有专家分析说，中国经济急速发展，加上女性越来越来越独立，另外，近年来简化离婚手续是其中一大原因。

——以上内容摘自第一视频门户

现代生活给人们施加的压力越来越大，离婚率的不断升高已成为现代社会的一大问题。而其中有许许多多的个案是由婚姻中的“不安定因素”引起的。妻子与丈夫吵架后，心如绞痛，于是寻求前男友的安慰，进而夫妻矛盾激化，最终以离婚收场，类似上述的案例数不胜数。

我们已知n对夫妻的婚姻状况，称第i对夫妻的男方为Bi，女方为Gi。若某男Bi与某女Gj曾经交往过（无论是大学，高中，亦或是幼儿园阶段，i≠j），则当某方与其配偶（即Bi与Gi或Bj与Gj）感情出现问题时，他们有私奔的可能性。不妨设Bi和其配偶Gi感情不和，于是Bi和Gj旧情复燃，进而Bj因被戴绿帽而感到不爽，联系上了他的初恋情人Gk……一串串的离婚事件像多米诺骨牌一般接踵而至。若在Bi和Gi离婚的前提下，这2n个人最终依然能够结合成n对情侣，那么我们称婚姻i为不安全的，否则婚姻i就是安全的。

给定所需信息，你的任务是判断每对婚姻是否安全。

输入格式

第一行为一个正整数n，表示夫妻的对数；

以下n行，每行包含两个字符串，表示这n对夫妻的姓名（先女后男），由一个空格隔开；

第n+2行包含一个正整数m，表示曾经相互喜欢过的情侣对数；

以下m行，每行包含两个字符串，表示这m对相互喜欢过的情侣姓名（先女后男），由一个空格隔开。

输出格式

输出文件共包含n行，第i行为“Safe”（如果婚姻i是安全的）或“Unsafe”（如果婚姻i是不安全的）。

输入输出样例

输入 #1复制

2
Melanie Ashley
Scarlett Charles
1
Scarlett Ashley

输出 #1复制

Safe
Safe

输入 #2复制

2
Melanie Ashley
Scarlett Charles
2
Scarlett Ashley
Melanie Charles

输出 #2复制

Unsafe
Unsafe

说明/提示

对于20%的数据，n≤20；

对于40%的数据，n≤100，m≤400；

对于100%的数据，所有姓名字符串中只包含英文大小写字母，大小写敏感，长度不大于8，保证每对关系只在输入文件中出现一次，输入文件的最后m行不会出现未在之前出现过的姓名，这2n个人的姓名各不相同，1≤n≤4000，0≤m≤20000。

思路：

         我们可以将题目中的男女关系进行建图，然后求出强连通分量，判断夫妻之间是否在同一强连通分量中，若在，则不安全，反之则安全。

        可以将 夫妻 关系 建为    female -> male ; 将 情人 关系建为 male-> female;

         p.s. 由于原题中需要输入字符串 （string）， 我们自己建立映射条件极为不方便 ，于是可以调用数据结构 map ：map <string, int> g 进行映射

        因为一共2*n个人 所以建图时 第 i 对夫妻，female 为 i 号节点 ，male 为i+n 号；

code

#include <bits/stdc++.h>
using namespace std;

const int N=30001;
map <string, int> g;
int n,m;
int head[N],next[N],ver[N],tot;

inline void add(int x,int y){
    ver[++tot]=y;
    next[tot]=head[x];
    head[x]=tot;
}

int s[N],top=0;
int v[N];
int dfn[N],low[N],ind=0;
int belong[N],cnt=0;

inline void tarjan(int x){
    dfn[x]=++ind;
    low[x]=ind;
    s[++top]=x;
    v[x]=1;
    for(int i=head[x];i;i=next[i]){
        int y=ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[y],low[x]);
        }
        else if(v[y]==1){
            low[x]=min(low[x],dfn[y]);
        }
    }
    if(low[x]==dfn[x]){
        ++cnt;
        do{
            belong[s[top]]=cnt;
            v[s[top]]=0;
        }while(s[top--]!=x);
    }
}    

inline int read(){
    int ans=0,f=1;
    char s=getchar();
    while(!isdigit(s)) f*=(s=='-')? -1:1,s=getchar();
    do ans=(ans<<1)+(ans<<3)+(s^48),s=getchar();
    while(isdigit(s));
    return ans*f;
}

int main(){
    n=read();
    string fe,ma;
    for(int i=1;i<=n;i++){
        cin>>fe>>ma;
        g[fe]=i;
        g[ma]=i+n;
        add(i,i+n);
    } 
    m=read();
    for(int i=1;i<=m;i++){
        cin>>fe>>ma;
        add(g[ma],g[fe]);
    }
    for(int i=1;i<=n*2;i++) if(dfn[i]==0) tarjan(i);
    for(int i=1;i<=n;i++){
        if(belong[i]==belong[i+n]) printf("Unsafe
");
        else printf("Safe
");    
    }
    return 0;
} 

No.3 消息扩散（来源：洛谷）

题目描述

有n个城市，中间有单向道路连接，消息会沿着道路扩散，现在给出n个城市及其之间的道路，问至少需要在几个城市发布消息才能让这所有n个城市都得到消息。

输入格式

第一行两个整数n,m表示n个城市，m条单向道路。

以下m行，每行两个整数b,e表示有一条从b到e的道路，道路可以重复或存在自环。

输出格式

一行一个整数，表示至少要在几个城市中发布消息。

输入输出样例

输入 #1复制

5 4
1 2
2 1
2 3
5 1

输出 #1复制

2

说明/提示

【数据范围】

对于20%的数据，n≤200;

对于40%的数据，n≤2,000;

对于100%的数据，n≤100,000，m≤500,000.

【限制】

时间限制：1s，内存限制：256M

【注释】

样例中在4,5号城市中发布消息。

思路：     

           题目中有重边和自环，那就判断不是重边与自环才建图，然后求强连通分量，入度为0 的顶点个数即为answer；

code             

#include<bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 500005;
int x,y,n,m,pointnum,tot,Ind,top,ans;
int head[N],nxt[M],to[M];
int low[N],dfn[N],s[N];
int belong[N],rd[N];
bool in[N];
inline int read() {
    int ans=0,f=1;
    char s=getchar();
    while(!isdigit(s)) f*=(s=='-')? -1:1,s=getchar();
    do ans=(ans<<1)+(ans<<3)+(s^48),s=getchar();
    while(isdigit(s));
    return ans*f;
}

inline void add(int x,int y) {
    nxt[++tot]=head[x];
    head[x]=tot;
    to[tot]=y;
}

inline void dfs(int x) {
    low[x]=dfn[x]=++Ind;
    s[++top]=x;
    in[x]=true;
    for(int i=head[x]; i; i=nxt[i]) {
        int v=to[i];
        if(!dfn[v]) {
            dfs(v);
            low[x]=min(low[x],low[v]);
        } else if(in[v]) low[x]=min(low[x],dfn[v]);
    }
    if(low[x]==dfn[x]) {
        ++pointnum;
        int j=-1;
        while(j!=x) {
            j=s[top--];
            belong[j]=pointnum;
            in[j]=false;
        }
    }
}

int main() {
    n=read(),m=read();
    for(int i=1; i<=m; i++) {
        x=read(),y=read();
        if(x!=y) add(x,y);
    }
    for(int i=1; i<=n; i++) if(!dfn[i]) dfs(i);
    for(int i=1; i<=n; i++)
        for(int e=head[i]; e; e=nxt[e])
            if(belong[i]!=belong[to[e]])
                rd[belong[to[e]]]++;
    for(int i=1; i<=pointnum; i++)
        if(!rd[i]) ans++;
    cout<<ans<<endl;
    return 0;
}

No.4 间谍网络（来源：洛谷）

题目描述

由于外国间谍的大量渗入，国家安全正处于高度的危机之中。如果A间谍手中掌握着关于B间谍的犯罪证据，则称A可以揭发B。有些间谍收受贿赂，只要给他们一定数量的美元，他们就愿意交出手中掌握的全部情报。所以，如果我们能够收买一些间谍的话，我们就可能控制间谍网中的每一分子。因为一旦我们逮捕了一个间谍，他手中掌握的情报都将归我们所有，这样就有可能逮捕新的间谍，掌握新的情报。

我们的反间谍机关提供了一份资料，包括所有已知的受贿的间谍，以及他们愿意收受的具体数额。同时我们还知道哪些间谍手中具体掌握了哪些间谍的资料。假设总共有n个间谍(n不超过3000)，每个间谍分别用1到3000的整数来标识。

请根据这份资料，判断我们是否有可能控制全部的间谍，如果可以，求出我们所需要支付的最少资金。否则，输出不能被控制的一个间谍。

输入格式

第一行只有一个整数n。

第二行是整数p。表示愿意被收买的人数，1≤p≤n。

接下来的p行，每行有两个整数，第一个数是一个愿意被收买的间谍的编号，第二个数表示他将会被收买的数额。这个数额不超过20000。

紧跟着一行只有一个整数r，1≤r≤8000。然后r行，每行两个正整数，表示数对(A, B)，A间谍掌握B间谍的证据。

输出格式

如果可以控制所有间谍，第一行输出YES，并在第二行输出所需要支付的贿金最小值。否则输出NO，并在第二行输出不能控制的间谍中，编号最小的间谍编号。

输入输出样例

输入 #1复制

3
2
1 10
2 100
2
1 3
2 3

输出 #1复制

YES
110

输入 #2复制

4
2
1 100
4 200
2
1 2
3 4

输出 #2复制

NO
3

思路：                                                                                                                                  

           不难发现有两种情况：

                               （1）. 此间谍没人能够揭发他，也不能够贿赂他，那么直接输出他的编号；

                               （2）.   1） 没有环，则资金为没有入度那个点的钱数；

                                             2）有环，则在环中找最小值；

code：

#include<bits/stdc++.h>
using namespace std;
struct ss{
    int next,to;
};ss data[200010];
const int inf=1e9+7;
int n,q,timeclock,p,top,cnt,ans,r;
int dfn[200010],low[200010],s[200010],instack[200010],next[200010],head[200010];
int belong[200010],money[200010],sum[200010],size[200010],rd[200010];
void add(int a,int b)
{
    data[++p].next=head[a];
    data[p].to=b;
    head[a]=p;
}
void tarjan(int a)          
{
    dfn[a]=low[a]=++timeclock;
    instack[a]=1;
    s[++top]=a;
    for(int i=head[a];i;i=data[i].next)
    {
        int v=data[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[a]=min(low[a],low[v]);
        }
        else
        if(instack[v])
        low[a]=min(low[a],dfn[v]);
    }
    if(dfn[a]==low[a])
    {
        cnt++;
        while(s[top+1]!=a)
        {
            belong[s[top]]=cnt;
            instack[s[top]]=0;
            size[cnt]++;
            sum[cnt]=min(sum[cnt],money[s[top]]);
            top--;
        }
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    money[i]=1e9+7;       
    for(int i=1;i<=n;i++)
    sum[i]=1e9;
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int u,mo;
        scanf("%d%d",&u,&mo);
        money[u]=mo;
    }
    scanf("%d",&r);
    for(int i=1;i<=r;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v);
    }
    for(int i=1;i<=n;i++)
    if(!dfn[i]&&money[i]!=inf)   
    tarjan(i);
    for(int i=1;i<=n;i++)      
    if(!dfn[i])
    {
        printf("NO
");
        printf("%d
",i);
        return 0;
    }

    for(int i=1;i<=n;i++)
    for(int j=head[i];j;j=data[j].next)
    if(belong[i]!=belong[data[j].to])
    {
        rd[belong[data[j].to]]++;   
    }
    printf("YES
");
    for(int i=1;i<=cnt;i++)
    {
       if(!rd[i])
       { 
           ans+=sum[i];
       }
    }
    printf("%d
",ans);
    return 0;
}