一个有向图 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≤105,
1≤M≤106,
1≤X≤108
输入样例：
6 6 20070603
1 2
2 1
1 3
2 4
5 6
6 4
输出样例：
3
3

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

using namespace std;

typedef long long LL;

const int N = 100010, M = 2000010;

int n, m, mod;
int h[N], hs[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int f[N], g[N];
// 有新图所以传h
void add(int h[],int a,int b)
{
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++timestamp;
    stk[++top] = u,in_stk[u] = true;
    for(int i =h[u];~i;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]);
    }
    // 当前分量最高点 把当前点取出来作为一个强连通分量
    // ⭐
    // 解释一下为什么tarjan完是逆dfs序
    // 假设这里是最高的根节点fa
    // 上面几行中 fa的儿子节点j都已经在它们的递归中走完了下面9行代码
    // 其中就包括 ++scc_cnt 
    // 即递归到高层节点的时候 子节点的scc都求完了
    // 节点越高 scc_id越大
    // 在我们后面想求链路dp的时候又得从更高层往下
    // 所以得for(int i=scc_cnt(根节点所在的scc);i;i--)开始
    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;
        do{//由于是dfs搜到一层stk.push 所以stk最先pop出来的是最深层的
            y=stk[top--];
            in_stk[y] = false;
            // id[y] = scc_cnt 属于第scc_cnt个强连通分量
            id[y] = scc_cnt;
            scc_size[scc_cnt]++;
        }while(y!=u);
    }
}

int main()
{
    memset(h,-1,sizeof h);
    memset(hs,-1,sizeof hs);
    cin >> n >> m >> mod;
    while(m--)
    {
        int a,b;
        cin >> a >> b;
        add(h,a,b);
    }
    // tarjan算强连通分量
    for(int i = 1;i<=n;i++)
    {
        if(!dfn[i])
        {
            tarjan(i);
        }
    }
    unordered_set<LL> S;// 边是(u,v) hash后 u*1000000+v
    for(int i=1;i<=n;i++)
    {
        for(int j = h[i];~j;j=ne[j])
        {
            int k = e[j];
            int a = id[i],b= id[k];
            // 边判重
            LL hash = a*1000000ll+b;
            // 如果a和b不在一个强连通分量 且 边(a,b)没被加过
            if(a!=b && !S.count(hash))
            {
                add(hs,a,b);
                S.insert(hash);
            }
        }
    }
    // 强连通分量算完后
    // 拓扑序一定是按照节点编号递减的顺序->不需要重新拓扑排序了
    // 在这个拓扑序上求最长路
    for(int i=scc_cnt;i;i--)
    {
        // !f[i] i没被更新过 i为一条链的起点
        if(!f[i])
        { 
            f[i] = scc_size[i];
            g[i] = 1;
        }
        for(int j = hs[i];~j;j=ne[j])
        {
            int k = e[j];
            if(f[k]<f[i]+scc_size[k])
            {
                f[k] = f[i]+scc_size[k];
                g[k] = g[i];
            }
            else if(f[k]==f[i]+scc_size[k])
            {
                g[k] = (g[k]+g[i])%mod;
            }
        }
    }

    int maxf = 0,sum = 0;
    // 对比每一条路终点
    for(int i = 1;i<=scc_cnt;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;
    return 0;
}