有向图的强连通分量——最大半连通子图

二次元入口：最大半连通子图

思路:

首先从题目里面提取信息，半连通的意思是两点u,v之间满足u->v或者v->u,强连通则是两者都满足，半连通子图的定义就是在一个导出子图里面的任意两点都满足半连通。

对给定图进行一遍tarjan算法后进行缩点，原图就会变成一个拓扑图。

图上的每一个节点都是一个强连通分量，里面的点都满足半连通，设每一个点上的权值就是里面的点的数量，要找到最大的半连通子图就是要找到拓扑图上权值和最大的一条无分叉的路径，也就是一条拓扑链。这条链上的权值之和就是第一问的答案。

为了找到权值和最大的点，原本应该从每一个起点(入度为0的点)出发做一遍最长路，但因为这个图是拓扑图，可以采用递推的方式来求每一个节点来自不同方向入度的最大权值和再加上自身的权值。

但是因为是用原本的边进行拓扑图的连边，有可能出现两个强连通分量由相同的边进行反复相连，这里会影响到第二问里面的求方案数，所以连边的时候要进行判重。

连完拓扑图的边之后就可以开始求f[i]和g[i],这里f[i]是以节点i为终点的最大路径权值之和，g[i]表示的是以i为终点的最大路径权值之和的方案数。

步骤：

1.走一遍tarjan算法求出强连通分量编号并进行缩点。

2.由缩完点后的编号进行构造拓扑图(要对边进行判重)。

3.递推求出拓扑图上每一个节点的f[i]和g[i].

4.遍历一次递推数组，找到最大半连通子图的点的数量，并记录不同最大半连通子图的数量。
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_set>
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 dfn[N],low[N],times;
int stk[N],top;
bool in_stk[N];
int id[N],scc_cnt,cnt[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]=++times;
         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(low[u]==dfn[u])
         {
             ++scc_cnt;
             int y;
             do{
            y=stk[top--];
            in_stk[y]=false;
            id[y]=scc_cnt;
            cnt[scc_cnt]++;
             }while(y!=u);
         }
}
int main()
{
    memset(h,-1,sizeof h);
    memset(hs,-1,sizeof hs);
    scanf("%d%d%d",&n,&m,&mod);
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(h,a,b);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i])
        tarjan(i);

    unordered_set<ll>s;

    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 hash1=a*1000000ll+b;
        if(a!=b&&!s.count(hash1)) //对边进行判重
        {
            add(hs,a,b);
            s.insert(hash1);
        }
    }

    for(int i=scc_cnt;i;i--)
    {
        if(!f[i])
        {
            f[i]=cnt[i];
            g[i]=1;
        }
        for(int j=hs[i];~j;j=ne[j])
        {
             int k=e[j];
            if(f[k]<f[i]+cnt[k])
            {
                f[k]=f[i]+cnt[k];
                g[k]=g[i];
            }else if(f[k]==f[i]+cnt[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;
}