1175. 最大半连通子图

一个有向图 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

思路：

/*
强连通分量:u->v并且v->u
半连通子图:u->v或者v->u

可知:强连通分量必然是半连通子图

根据半连通子图定义:u->v或者v->u,正好符合了拓扑图.

然后本题让求的是最大半连通子图的点数和方案数.既然强连通分量必然是半连通子图,那么我们选这个强连通分量里面的点把整个强连通分量里面的点全部选上肯定是最优的，那么我们可以tarjan缩点,记录一下这个强连通分量有多少个点，所有强连通分量缩完点后就是一个拓扑图,成为一个点权图.最后跑一下最长路即可.因为是拓扑图,所以可以递推求解.

虽然缩点后是一个拓扑图,但是从哪里开始呢? 我们发现tarjan是深度优先搜索的,那么最下面的强连通分量是编号最小的,因为搜到最下面他是第一个被搜完的，然而越靠上的强连通分量,编号越大,所以我们倒着递推就可以了(从最大的编号开始)

最后求方案的时候,要把拓扑图的重边过滤掉,防止算多次。
*/

代码：

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

const int N = 1e5 + 10, M = 2e6 + 10;
int n, m, mod;
int h[N], hs[N], ne[M], e[M], idx;
int stk[N], top;
int dfn[N], low[N], timestamp;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int f[N], g[N];

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 != -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 (dfn[u] == low[u])
    {
        int y;
        ++scc_cnt;
        do
        {
            y = stk[top--];
            scc_size[scc_cnt]++;
            id[y] = scc_cnt;
            in_stk[y] = false;
        } while (y != u);
    }
}

int main()
{
    scanf("%d %d %d", &n, &m, &mod);
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);

    for (int i = 0; i < m; i++)
    {
        int a, b;
        scanf("%d %d", &a, &b);
        add(h, a, b);
    }

    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
            tarjan(i);
    }

    // 不支持pair 手写哈希
    unordered_set<LL> S;         // (u, v) -> u * 1000000 + v
    for (int u = 1; u <= n; u++) // 可能两个强连通分量之间不止一条边 只需要选一条（信息在点上）
    {
        for (int i = h[u]; i != -1; i = ne[i])
        {
            int j = e[i];
            int a = id[u], b = id[j];
            LL hash = a * 1000000ll + b;
            if (a != b && !S.count(hash))
            {
                add(hs, a, b);
                S.insert(hash);
            }
        }
    }

    // 求完强连通分量后的顺序 其实就是topsort后的结果（dfs）
    for (int i = scc_cnt; i != 0; i--)
    {
        // 求最长路
        if (!f[i])
            f[i] = scc_size[i], g[i] = 1;
        for (int k = hs[i]; k != -1; k = ne[k])
        {
            int j = e[k];
            if (f[j] < f[i] + scc_size[j])
            {
                f[j] = f[i] + scc_size[j];
                g[j] = g[i];
            }
            else if (f[j] == f[i] + scc_size[j])
                g[j] = (g[j] + g[i]) % mod;
        }
    }

    int maxx = 0, sum = 0;
    for (int i = 1; i <= scc_cnt; i++)
    {
        if (f[i] > maxx)
        {
            maxx = f[i];
            sum = g[i];
        }
        else if (f[i] == maxx)
        {
            sum = (sum + g[i]) % mod;
        }
    }

    printf("%d\n", maxx);
    printf("%d\n", sum);

    return 0;
}