最大半连通子图(有向图的强连通分量&dp)

题目：https://www.acwing.com/problem/content/1177/

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

题解：将图转换成拓扑图后(求最大连通块、缩点，对连通块重新建图)，求一条链，这一条链上的点的个数最多，并且要输出这样的链有多少个，可以根据拓扑序列进行的dp，用两个数组f[N]、g[N]，f[N]代表，以i为链的终点，走到这里的最大数量是多少，在这个数量下的方案数为g[i]。

#include <bits/stdc++.h>
//#define int long long
#define pb push_back
#define pii pair<int, int>
#define mpr make_pair
#define ms(a, b) memset((a), (b), sizeof(a))
#define x first
#define y second
typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
inline int read() {
    char ch = getchar();
    int s = 0, w = 1;
    while (ch < '0' || ch > '9') {
        if (ch == '-') w = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        s = s * 10 + ch - '0', ch = getchar();
    }
    return s * w;
}

const int N = 100010, M = 2000010;
int n, m, mod;
int h[N], hs[N], e[M], ne[M], idx;  // hs用来重新建连通块的图
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, id_size[N];
int f[N], g[N];  // dp，用来求最多的数量，并且在这个数量下最多的方案数
// f[N]代表，以i为链的终点，走到这里的最大数量是多少，在这个数量下的方案数为g[i]

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]);
    }
    if (dfn[u] == low[u]) {
        ++scc_cnt;
        int y;
        do {
            y = stk[top--];
            in_stk[y] = false;
            id[y] = scc_cnt;
            id_size[scc_cnt]++;
        } while (y != u);
    }
}
signed main() {
    memset(h, -1, sizeof(h));
    memset(hs, -1, sizeof(hs));

    n = read(), m = read(), mod = read();
    while (m--) {
        int a = read(), b = read();
        add(h, a, b);
    }
    for (int i = 1; i <= n; i++)
        if (!dfn[i]) tarjan(i);
    //重新建图，扫描所有的边，如果不在同一个连通块，就可以将这两个连通块直接建条边
    //但是要注意去重，用哈希set去重，因为哈希不支持pair类型,就要再对这俩数自定义一个哈希
    //因为u和v都小于1000000，所以将u*1000000再加上v，这个数就不会有重的了
    unordered_set<ll> S;  //(u,v)->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 = (ll)a * 1000000 + b;//对俩数进行一个哈希映射
            if (a != b && !S.count(hash)) {
                add(hs, a, b);
                S.insert(hash);
            }
        }
    }
    //tarjan跑出来的连通块的逆序就已经是拓扑序列了
    //下面有点类似迪杰斯特拉里面的那个更新
    for (int i = scc_cnt; i; i--) {
        if (!f[i]) {//如果这个数还没遍历到，就让它等于自己数量
            f[i] = id_size[i];
            g[i] = 1;
        }
        for (int j = hs[i]; ~j; j = ne[j]) {
            int k = e[j];
            if (f[k] < f[i] + id_size[k]) {
                f[k] = f[i] + id_size[k];
                g[k] = g[i];
            } else if (f[k] == f[i] + id_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;
    }
    printf("%d\n", maxf);
    printf("%d\n", sum);
    return 0;
}