《信息学奥赛一本通》 , ZJOI2007 tarjan 最大半联通子图

一个有向图 G=(V,E) 称为半连通的 (Semi-Connected)，如果满足：∀u,v∈V，满足 u→v 或 v→u，即对于图中任意两点 u,v，存在一条 u 到 v 的有向路径或者从 v 到 u 的有向路径。

若 G′=(V′,E′) 满足，E′ 是 E 中所有和 V′ 有关的边，则称 G′ 是 G 的一个导出子图。

若 G′ 是 G 的导出子图，且 G′ 半连通，则称 G′ 为 G 的半连通子图。

若 G′ 是 G 所有半连通子图中包含节点数最多的，则称 G′ 是 G 的最大半连通子图。

给定一个有向图 G，请求出 G 的最大半连通子图拥有的节点数 K，以及不同的最大半连通子图的数目 C。

由于 C 可能比较大，仅要求输出 C 对 X 的余数。

输入格式

第一行包含三个整数 N,M,X。N,M 分别表示图 G 的点数与边数，X 的意义如上文所述；

接下来 M 行，每行两个正整数 a,b，表示一条有向边 (a,b)。

图中的每个点将编号为 1 到 N，保证输入中同一个 (a,b) 不会出现两次。

输出格式

应包含两行。

第一行包含一个整数 K，第二行包含整数 C mod X。

数据范围

1≤N≤10^5,
1≤M≤10^6,
1≤X≤10^8

输入样例：

6 6 20070603
1 2
2 1
1 3
2 4
5 6
6 4

输出样例：

3
3

难度：中等

时/空限制：2s / 64MB

总通过数：2729

总尝试数：6365

来源：《信息学奥赛一本通》 , ZJOI2007

算法标签

这题我们用的是tarjan算法

若不懂tarjan可以看看这篇：(15条消息) 有向图强连通分量tarjan算法详解（适合新手） + 模板题：《信息学奥赛一本通》 , USACO , HAOI2006 受欢迎的牛_wsh1931的博客-CSDN博客 

1：先求一遍最大联通分量。要选出他的子联通分量要保证图不分叉

即不能出现如图情况不然点1，2不能互通。 

2: 因为tarjan算法是按照先遍历的点后输出的所以连通块的逆序即为拓扑图：

若要求半联通分量的最大节点数以及方案，即求缩点之后的拓扑图的最大节点数以及方案

这里要注意一个细节：题目要求的半联通子图是点不同，而不是边不同因此我们要把边判重。

如图若是存在重边，则方案2会被更新多次

代码如下：

#include <stack>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <unordered_set>

using namespace std;

typedef long long LL;

const int N = 100010, M = 2000010;

int id[N];
int n, m, mod;
int f[N], g[N];//f[i] 表示以 i 为终点的包含最大节点数的拓扑图.
stack<int> stk;//g[i] 表示他的方案数
bool in_stk[N];
int scc_cnt, Size[N];
int dfn[N], low[N], timestamp;
int h[N], hs[N], e[M], ne[M], idx;//hs是边判重之后的邻接表

void add(int h[], int a, int b)//邻接表模板
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx;
    idx ++ ;
}

void tarjan(int u)//tarjan算法模板
{
    dfn[u] = low[u] = ++ timestamp;
    stk.push(u), in_stk[u] = true;
    
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if (in_stk[j]) low[u] = min(low[u], dfn[j]);
    }
    
    if (low[u] == dfn[u])
    {
        int y;
        scc_cnt ++ ;
        
        do
        {
            y = stk.top();
            stk.pop();
            in_stk[y] = false;
            id[y] = scc_cnt;
            Size[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    cin >> n >> m >> mod;
    
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);
    
    while (m -- )
    {
        int a, b;
        scanf("%d %d", &a, &b);
        add(h, a, b);
    }
    
    for (int i = 1; i <= n; i ++ )
        if (!dfn[i])
            tarjan(i);
    
    unordered_set<LL> S;
    for (int i = 1; i <= n; i ++ )//给边判重去掉多余边
        for (int j = h[i]; j != -1; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            
            LL hash = a * 100000ll + b;//最多有100000个点，可以映射成100000之外的数。
            if (a != b && !S.count(hash))//这样既不会影响之前输入的点，也可以把相同的点a, b
            {                            //映射成同一个值方便判重
                add(hs, a, b);
                S.insert(hash);
            }
        }
    
    for (int i = scc_cnt; i ; i -- )//从后往前是拓扑序
    {
        if (!f[i])//说明 i 还未遍历
        {
            f[i] = Size[i];//以i为终点的节点数为i中的节点数
            g[i] = 1;//初始时方案数为1
        }
        
        for (int j = hs[i]; j != -1; j = ne[j])//遍历整个判重后链表
        {
            int k = e[j];
            if (f[k] < f[i] + Size[k])//若以i为终点的节点数可以更新以k为终点的节点数。说明这是一条拓扑序
            {
                f[k] = f[i] + Size[k];//更新即可
                g[k] = g[i];
            }
            else if (f[k] == f[i] + Size[k])  g[k] = (g[k] + g[i]) % mod;//若相等说明这是两条不同的拓扑序
        }                                                                //则方案数要加上两条拓扑序
    }
    
    int maxd = 0, sum = 0;    
    for (int i = 1; i <= scc_cnt; i ++ )//遍历以每个点为终点的节点数的最大值
        if (maxd < f[i])//找出最大节点数
        {
            maxd = f[i];
            sum = g[i];
        }
        else if (maxd == f[i]) sum = (sum + g[i]) % mod;//若相等则加上他的方案数
    
    cout << maxd << endl << sum << endl;
    
    return 0;
}