BZOJ3887: [Usaco2015 Jan]Grass Cownoisseur

n<=100000个点m<=100000条边有向图，有一次机会沿着某条边反方向走一次，求从一号点出发最终到达一号点的路径经过的不同的点的数量的最大值。

tarjan缩完点，如果没机会反方向的话答案就是1所在的分量的大小。现在有了，其实就是1->1能到达的某个点->反向边->能到达1的某个点，所以只要知道1的分量到达每个分量的最多点数，以及每个分量到1的分量的经过最多点数，最后枚举边计算答案即可。这个经过最多点数，可以按拓扑序DP。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
//#include<queue>
#include<iostream>
using namespace std;

int n,m;
#define maxn 100011
#define maxm 200011
int Time=0,dfn[maxn],low[maxn],bel[maxn],sta[maxn],top=0,tot=0,cnt[maxn];bool insta[maxn];
struct Edge{int to,next;};
const int inf=0x3f3f3f3f;
struct Graph
{
    Edge edge[maxm];int first[maxn],le,ind[maxn],f[maxn];
    Graph() {memset(first,0,sizeof(first));le=2;}
    void in(int x,int y) {Edge &e=edge[le];e.to=y;e.next=first[x];first[x]=le++;}
    int que[maxn],head,tail;
    void topo()
    {
        head=tail=0;
        for (int i=1;i<=tot;i++) if (!ind[i]) que[tail++]=i;
        for (int i=1;i<=tot;i++) f[i]=-inf;f[bel[1]]=0;
        while (head!=tail)
        {
            const int now=que[head++];
//            cout<<now<<":)";
            f[now]+=cnt[now];
            for (int i=first[now];i;i=edge[i].next)
            {
                const Edge &e=edge[i];
                f[e.to]=max(f[e.to],f[now]);
                ind[e.to]--;
                if (!ind[e.to]) que[tail++]=e.to;
            }
        }
    }
}g,gg,ggg;
void tarjan(int x,int fa)
{
    low[x]=dfn[x]=++Time;
    sta[++top]=x;insta[x]=1;
    for (int i=g.first[x];i;i=g.edge[i].next)
    {
        const Edge &e=g.edge[i];
        if (!dfn[e.to]) tarjan(e.to,x),low[x]=min(low[x],low[e.to]);
        else if (insta[e.to]) low[x]=min(low[x],dfn[e.to]);
    }
    if (dfn[x]==low[x])
    {
        tot++;
        while (sta[top]!=x) bel[sta[top]]=tot,cnt[tot]++,insta[sta[top--]]=0;
        bel[sta[top]]=tot,cnt[tot]++,insta[sta[top--]]=0;
    }
}
int ans=0;
void tarjan()
{
    memset(dfn,0,sizeof(dfn));
    for (int i=1;i<=n;i++) if (!dfn[i]) tarjan(i,0);
    for (int i=1;i<=n;i++)
        for (int j=g.first[i];j;j=g.edge[j].next)
        {
            const Edge &e=g.edge[j];
            if (bel[i]!=bel[e.to])
            {
                gg.in(bel[i],bel[e.to]);
                gg.ind[bel[e.to]]++;
                ggg.in(bel[e.to],bel[i]);
                ggg.ind[bel[i]]++;
            }
        }
    gg.topo();ggg.topo();
    int ans=cnt[bel[1]];
    for (int i=2;i<gg.le;i++)
    {
        const int a=gg.edge[i].to,b=ggg.edge[i].to;
        ans=max(ans,ggg.f[b]+gg.f[a]-cnt[bel[1]]);
    }
    printf("%d\n",ans);
}
void init()
{
    scanf("%d%d",&n,&m);int x,y;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        g.in(x,y);
    }
}
int main()
{
    init();
    tarjan();
    return 0;
}