Acwing 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

思路：
对于每一个强连通分量，其一定是一个半连通子图。
故可以进行缩点。
但是有一个问题，缩点之后产生的新点之间，同一对新点之间可能会产生多条相同边。
这个问题在之前的两道题中也出现过，但是由于之前的两道题是统计入度和出度为0的点故并不影响。
但是本题涉及dp过程，所以需要保证两点之间只有一条边。
此处使用哈希表进行查重，保证两点之间最多只有一条边。

之后根据拓扑序进行dp，而scc_cnt的产生顺序就是根据拓扑序的倒叙产生的，故直接用scc_cnt倒叙就可以产生拓扑序。
f数组为从头开始，到现在的总旧点数
g数组为从头开始，到现在的方案数
代码：

#include<iostream>
#include<cstring>
#include<stack>
#include<unordered_set>
using namespace std;
int n, mod,m;
const int N = 1e5+10;
int h[N], hs[N], ne[20 * N ], e[20 * N], idx = 0;
int dfn[N], low[N], Size[N], id[N], scc_cnt = 0;
int Time = 0;
stack<int>stk;
bool in_stk[N];
unordered_set<long long>Hash[N];
int f[N], g[N]; // f记录节点数 g记录方案数
void add(int a, int b, int h[])
{
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx++;
}
void tarjan(int u)
{
	stk.push(u);
	in_stk[u] = true;
	low[u] = dfn[u] = ++Time;
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (dfn[j] == 0)
		{
			tarjan(j);
			low[u] = min(low[j], low[u]);
		}
		else if(in_stk[j])
		{
			low[u] = min(low[u], low[j]);
		}
	}

	if (dfn[u] == low[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()
{
	memset(h, -1, sizeof h);
	memset(hs, -1, sizeof hs);
	cin >> n >> m >> mod;
	for (int i = 0; i < m; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		//cin >> a >> b;
		add(a, b, h);
	}

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

	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];
			int b = id[k];
			if (a != b && !Hash[a].count(b))
			{
				add(a, b, hs);
				Hash[a].insert(b);
			}
		}
	}

	for (int i = scc_cnt; i != 0; i--)
	{
		if (!f[i])
		{
			f[i] = Size[i];
			g[i] = 1;
		}
		for (int j = hs[i]; j != -1; j = ne[j])
		{
			int k = e[j];
			if (f[k] < f[i] + Size[k])
			{
				f[k] = f[i] + Size[k];
				g[k] = g[i];
			}
			else if (f[k] == f[i] + Size[k])
			{
				g[k] = (g[i] + g[k]) % mod;
			}
		}
	}

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