Description
一个有向图G=(V,E)称为半连通的(Semi-Connected),如果满足:?u,v∈V,满足u→v或v→u,即对于图中任意
两点u,v,存在一条u到v的有向路径或者从v到u的有向路径。若G'=(V',E')满足V'?V,E'是E中所有跟V'有关的边,
则称G'是G的一个导出子图。若G'是G的导出子图,且G'半连通,则称G'为G的半连通子图。若G'是G所有半连通子图
中包含节点数最多的,则称G'是G的最大半连通子图。给定一个有向图G,请求出G的最大半连通子图拥有的节点数K
,以及不同的最大半连通子图的数目C。由于C可能比较大,仅要求输出C对X的余数。
Input
第一行包含两个整数N,M,X。N,M分别表示图G的点数与边数,X的意义如上文所述接下来M行,每行两个正整
数a, b,表示一条有向边(a, b)。图中的每个点将编号为1,2,3…N,保证输入中同一个(a,b)不会出现两次。N ≤1
00000, M ≤1000000;对于100%的数据, X ≤10^8
Output
应包含两行,第一行包含一个整数K。第二行包含整数C Mod X.
Sample Input
6 6 20070603
1 2
2 1
1 3
2 4
5 6
6 4
Sample Output
3
3
强连通图都属于半连通子图,所以先缩点,形成DAG,在DAG上跑拓扑,找最长链,拓扑的过程中dp计数
注意缩点之后的新图有重边
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 1000005;
int MOD;
//-----------------------有向图找强连通分量------------------------
struct Edge
{
int to,Next;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int num[MAXN];
void addedge(int u,int v)
{
edge[tot].to = v;
edge[tot].Next = head[u];
head[u] = tot++;
}
void Tarjan(int u)
{
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for(int i = head[u]; i != -1; i = edge[i].Next) {
v = edge[i].to;
if(!DFN[v]) {
Tarjan(v);
if(Low[u] > Low[v]) Low[u] = Low[v];
}
else if(Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
if(Low[u] == DFN[u]) {
scc++;
do {
v = Stack[--top];
Instack[v] = false;
Belong[v] = scc;
num[scc]++;
}
while(v != u);
}
}
void solve(int N)
{
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
memset(num,0,sizeof(num));
Index = scc = top = 0;
for(int i = 1; i <= N; i++) {
if(!DFN[i]) {
Tarjan(i);
}
}
}
//-----------------------有向图找强连通分量------------------------
vector<int> G[MAXN];
int In[MAXN],dp[MAXN],cnt[MAXN];
int vis[MAXN];
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
memset(In,0,sizeof(In));
memset(vis,0,sizeof(vis));
}
void Tp()
{
queue<int> q;
for(int i = 1; i <= scc; i++) {
if(!In[i]) {
dp[i] = num[i];
cnt[i] = 1;
q.push(i);
}
}
while(!q.empty()) {
int u = q.front();q.pop();
for(int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
In[v]--;
if(!In[v]) q.push(v);
if(vis[v] != u) {
if(dp[v] < dp[u] + num[v]) {
dp[v] = dp[u] + num[v];
cnt[v] = cnt[u];
}
else if(dp[v] == dp[u] + num[v]) {
cnt[v] = (cnt[v] + cnt[u]) % MOD;
}
}
vis[v] = u;
}
}
}
int main(void)
{
int n,m,u,v,ans,anssum;
while(scanf("%d %d %d",&n,&m,&MOD) != EOF) {
init();
while(m--) {
scanf("%d %d",&u,&v);
addedge(u,v);
}
solve(n);
for(int i = 1; i <= n; i++) G[i].clear();
for(int i = 1; i <= n; i++) {
u = Belong[i];
for(int j = head[i]; j != -1; j = edge[j].Next) {
v = Belong[edge[j].to];
if(u != v) {
G[u].push_back(v);
In[v]++;
}
}
}
Tp();
ans = 0,anssum = 0;
for(int i = 1; i <= scc; i++) {
if(ans < dp[i]) ans = dp[i],anssum = cnt[i];
else if(ans == dp[i]) anssum = (anssum + cnt[i]) % MOD;
}
printf("%d\n%d\n",ans,anssum);
}
return 0;
}
/*
1
5 5
1 2
2 3
3 1
4 1
5 2
*/