有向图强联通分量

Tarjan算法求强连通分量（scc）

---

定义两个时间戳：dfn[u]表示遍历每个点第一次遍历的时间，low[u]表示遍历到的最小时间戳是多少，u是其在强联通分量的最高点，等价于dfn[u] = low[u]

---

模板

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#define f first
#define s second
using namespace std;
const int N = 5e3 + 10;
int out[N], in[N];
int dfn[N], low[N], sccn[N];//dfn表示的是最早到达该点的时间戳
//low表示该点能搜索到的最小的时间搓是多少
//sccn表示的是该节点属于哪个强连通分量
int sccnum, T, n, Index;
int head[N], idx;
stack<int> str;
struct node
{
    int to, next;
}e[N];

inline void add(int to, int from)
{
   e[idx] = {to,head[from]};
   head[from] = idx ++;
}

void Tarjan(int root)
{
    if(dfn[root]) return;//如果被访问过就return
    dfn[root] = low[root] = ++ Index;
    str.push(root);//入栈
    for(int i = head[root]; ~i; i = e[i].next)//遍历该点连的边
    {
        int v = e[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            low[root] = min(low[v],low[root]);//更新子节点能到达的
        }
        else if(!sccn[v])//如果在在访问的路径上
            low[root] = min(low[root],dfn[v]);
    }
    if(low[root] == dfn[root]) // 一个强连通分量的最后一个点
    {
        sccnum ++;
        while(1)
        {
            int v = str.top();
            sccn[v] = sccnum;
            str.pop();
            //size[sccnum] ++ 求连通块大小
            if(v == root || str.empty()) break;
        }
    }
}

inline void init()
{
     memset(head,-1,sizeof(head));
     memset(low,0,sizeof(low));
     memset(dfn,0,sizeof(dfn));
     memset(sccn,0,sizeof(sccn));
     memset(in, 0, sizeof(in));
     memset(out,0,sizeof(out));
     while(!str.empty()) str.pop();
     idx = Index = sccnum = 0;
}

int main()
{
    while(cin >> T)
    {
        init();
        for(int i = 1; i <= T; ++ i)
        {
        while(cin >> n && n)
            add(n,i);
        }
       for(int i = 1; i <= T; ++ i)
          Tarjan(i);
          
       for(int i = 1; i <= T; ++ i)
        for(int j = head[i]; ~j; j = e[j].next)
        {   
          int v = e[j].to;
          if(sccn[i] != sccn[v])
           in[sccn[v]] = 1, out[sccn[i]] = 1;
        }
        
       int ans1 = 0;
       int ans2 = 0;
       if(sccnum != 1)
       {
          for(int i = 1; i <= sccnum; ++ i)
          {
           if(!out[i]) ++ ans2;
           if(!in[i]) ++ ans1;
           }
           ans2 = max(ans2,ans1);
       }
       else ans1 = 1;
       cout << ans1 << "\n" << ans2 << endl;
    }
    
    return 0;
}

---

注意Tarjan算法缩点之后的图是一个又向无环图具有严格的拓扑序,并且时间戳递减

---

用法1：添加边数把有向图变成强连通分量

设入度为0的点有p个，出度为0的点是Q个，加边数max(P,Q)
先缩点再去判断出入度

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#define f first
#define s second
using namespace std;
const int N = 5e3 + 10;
int out[N], in[N];
int dfn[N], low[N], sccn[N];//dfn表示的是最早到达该点的时间戳
//low表示该点能搜索到的最小的时间搓是多少
//sccn表示的是该节点属于哪个强连通分量
int sccnum, T, n, Index;
int head[N], idx;
stack<int> str;
struct node
{
    int to, next;
}e[N];

inline void add(int to, int from)
{
   e[idx] = {to,head[from]};
   head[from] = idx ++;
}

void Tarjan(int root)
{
    if(dfn[root]) return;//如果被访问过就return
    dfn[root] = low[root] = ++ Index;
    str.push(root);//入栈
    for(int i = head[root]; ~i; i = e[i].next)//遍历该点连的边
    {
        int v = e[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            low[root] = min(low[v],low[root]);//更新子节点能到达的
        }
        else if(!sccn[v])
            low[root] = min(low[root],dfn[v]);
    }
    if(low[root] == dfn[root]) // 一个强连通分量的最后一个点
    {
        sccnum ++;
        while(1)
        {
            int v = str.top();
            sccn[v] = sccnum;
            str.pop();
            if(v == root || str.empty()) break;
        }
    }
}

inline void init()
{
     memset(head,-1,sizeof(head));
     memset(low,0,sizeof(low));
     memset(dfn,0,sizeof(dfn));
     memset(sccn,0,sizeof(sccn));
     memset(in, 0, sizeof(in));
     memset(out,0,sizeof(out));
     while(!str.empty()) str.pop();
     idx = Index = sccnum = 0;
}

int main()
{
    while(cin >> T)
    {
        init();
        for(int i = 1; i <= T; ++ i)
        {
        while(cin >> n && n)
            add(n,i);
        }
       for(int i = 1; i <= T; ++ i)
          Tarjan(i);
          
       for(int i = 1; i <= T; ++ i)
        for(int j = head[i]; ~j; j = e[j].next)
        {   
          int v = e[j].to;
          if(sccn[i] != sccn[v])
           in[sccn[v]] = 1, out[sccn[i]] = 1;
        }
        
       int ans1 = 0;
       int ans2 = 0;
       if(sccnum != 1)
       {
          for(int i = 1; i <= sccnum; ++ i)
          {
           if(!out[i]) ++ ans2;
           if(!in[i]) ++ ans1;
           }
           ans2 = max(ans2,ans1);
       }
       else ans1 = 1;
       cout << ans1 << "\n" << ans2 << endl;
    }
    
    return 0;
}

---

用法2：求半联通分量的个数

什么是半联通分量就是说一个联通分量里面u可以到v或者u可以到v满足一个就可以了

---

题目：
一个有向图G=(V,E)称为半连通的(Semi-Connected)，如果满足：?u,v∈V，满足u→v或v→u，即对于图中任意
两点u，v,存在一条u到v的有向路径或者从v到u的有向路径。若G’=(V’,E’)满足V’?V，E’是E中所有跟V’有关的边，
则称G’是G的一个导出子图。若G’是G的导出子图，且G’半连通，则称G’为G的半连通子图。若G’是G所有半连通子图
中包含节点数最多的，则称G’是G的最大半连通子图。给定一个有向图G，请求出G的最大半连通子图拥有的节点数K
，以及不同的最大半连通子图的数目C。由于C可能比较大，仅要求输出C对X的余数。
精髓就是hash哪里，如何hash的pair

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 2e5 + 10, M = 2e6 + 10;
struct node {
    int to, next;
}e[M];
int head[N],cnt, headscc[N], idx;
int dfn[N], low[N], sccnum, scc[N], Size[N];
int n,m,mod;
int f[N], g[N];
stack<int> str;
inline void add(int h[], int from, int to)
{
    e[cnt] = {to,h[from]};
    h[from] = cnt ++;
}

inline void Tarjan(int u)
{
    dfn[u] = low[u] = ++ idx;
    str.push(u);
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            low[u] = min(low[v],low[u]);
        }
        else if(!scc[v])
          low[u] = min(low[u],dfn[v]);
    }
    
    if(low[u] == dfn[u])
    {
        sccnum ++;
        while(1)
        {
            int top = str.top();
            scc[top] = sccnum;
            Size[sccnum] ++;
            str.pop();
            if(top == u) break;
        }
    }
}

int main()
{
    memset(head,-1, sizeof (head));
    memset(headscc,-1,sizeof (headscc));
    
    cin >> n >> m >> mod;
    while(m --)
    {
       int l, r;
       cin >> l >> r;
       add(head,l,r);
    }
    
    for(int i = 1; i <= n; ++ i)
      if(!dfn[i])
       Tarjan(i);
    unordered_set<LL> S;//hash u->v u * 10000ll + v; 
    for(int i = 1; i <= n; ++ i)
      for(int j = head[i]; ~j; j = e[j].next)
      {
          int v = e[j].to;
          int Hash = scc[i] * 1000000ll + scc[v];
          if(scc[v] != scc[i] && !S.count(Hash))
          {
              add(headscc,scc[i],scc[v]);
              S.insert(Hash);
          }
      }
   //运用一个定义，就是说完点之后建图是有拓扑序的最大的就是初始起点
   //求最长路权值最大 
   for(int i = sccnum; i; -- i)
   {
       if(!f[i])
       {
           f[i] = Size[i];
           g[i] = 1;
       }
       for(int j = headscc[i]; ~j; j = e[j].next)
       {
           int v = e[j].to;
           if(f[v] < f[i] + Size[v])
           {
              f[v] = f[i] + Size[v];
              g[v] = g[i];
           }
           else if(f[v] == f[i] + Size[v])
             g[v] = (g[v] + g[i]) % mod;
       }
   }
   
   int maxf = 0, sum = 0;
   for(int i = 1; i <= sccnum; ++ i)
      if(f[i] > maxf)
      {
          maxf = f[i];
          sum = g[i];
      }
      else if (f[i] == maxf)
        sum = (sum + g[i]) % mod;
    
   cout << maxf << endl;
   cout << sum << endl;
   return 0;
}