解题：USACO15JAN Grass Cownoisseur

解题

首先缩点没啥可说的，然后考虑枚举这次逆行的边。具体来说在正常的图和反图上各跑一次最长路，然后注意减掉起点的贡献，用拓扑排序实现(我这里瞎写了个Bellman_Ford，其实在DAG上这好像和拓扑排序的复杂度是一样的=。=)

一个细节：注意可能整个图是个强连通分量，所以答案初始是起点所在的强联通分量的大小

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std; 
const int N=100005;
int dfn[N],low[N],col[N],stk[N],ins[N],inq[N],siz[N],dis[2][N];
int p[N],noww[N],goal[N],P[N][2],Noww[N][2],Goal[N][2]; 
int n,m,c,t1,t2,cnt,cnt0,cnt1,tot,top,ans; 
queue<int> qs;
void link(int f,int t) 
{ 
    noww[++cnt]=p[f]; 
    goal[cnt]=t,p[f]=cnt; 
} 
void relink(int f,int t)
{
    Noww[++cnt0][0]=P[f][0];
    Goal[cnt0][0]=t,P[f][0]=cnt0;
    Noww[++cnt1][1]=P[t][1];
    Goal[cnt1][1]=f,P[t][1]=cnt1;
}
void Tarjan_SCC(int nde)
{
    dfn[nde]=low[nde]=++tot;
    stk[++top]=nde,ins[nde]=true;
    for(int i=p[nde];i;i=noww[i])
        if(!dfn[goal[i]]) 
            Tarjan_SCC(goal[i]),low[nde]=min(low[nde],low[goal[i]]);
        else if(ins[goal[i]])
            low[nde]=min(low[nde],low[goal[i]]);
    if(dfn[nde]==low[nde])
    {
        c++; int tmp;
        do
        {
            tmp=stk[top--];
            ins[tmp]=false;
            col[tmp]=c,siz[c]++;
        }while(nde!=tmp);
    }
}
void Bellman_Ford(int s,int t)
{
    memset(dis[t],0xc0,sizeof dis[t]);
    dis[t][s]=siz[s],qs.push(s),inq[s]=true;
    while(!qs.empty())
    {
        int tn=qs.front(); 
        qs.pop(),inq[tn]=false;
        for(int i=P[tn][t];i;i=Noww[i][t])
            if(dis[t][Goal[i][t]]<dis[t][tn]+siz[Goal[i][t]])
            {
                dis[t][Goal[i][t]]=dis[t][tn]+siz[Goal[i][t]];
                if(!inq[Goal[i][t]]) 
                    qs.push(Goal[i][t]),inq[Goal[i][t]]=true;
            }
    }
}
int main() 
{ 
    scanf("%d%d",&n,&m); 
    for(int i=1;i<=m;i++) 
        scanf("%d%d",&t1,&t2),link(t1,t2);
    for(int i=1;i<=n;i++)
        if(!dfn[i]) Tarjan_SCC(i);
    for(int i=1;i<=n;i++)
        for(int j=p[i];j;j=noww[j])
            if(col[i]!=col[goal[j]])
                relink(col[i],col[goal[j]]); 
    Bellman_Ford(col[1],0),Bellman_Ford(col[1],1),ans=siz[col[1]];
    for(int i=1;i<=c;i++)
        for(int j=P[i][1];j;j=Noww[j][1])
            ans=max(ans,dis[0][i]+dis[1][Goal[j][1]]-siz[col[1]]);
    printf("%d",ans);
    return 0;
}