广告：

#include <stdio.h>
int main()
{
    puts("转载请注明出处[vmurder]谢谢");
    puts("网址：blog.csdn.net/vmurder/article/details/44081931");
}

题意：

给一个有向图，然后选一条路径起点终点都为1的路径出来，有一次机会可以沿某条边逆方向走，问最多有多少个点可以被经过？（一个点在路径中无论出现多少次($\geq$1)对答案的贡献均为1）

题解：

首先强连通分量缩点。
然后形成了dfs统计出：
集合A：点 $1$ 能到哪些点,
集合B：哪些点能到点 $1$
然后这两个集合各为拓扑图。
现在一条从1出发，最后又回到1的最长路径就可以被表示为1~A中某点a最长链+此点通过逆向边直接回到集合B中某点b后1~b的最长链。

代码：

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 501000
using namespace std;
struct KSD
{
    int v,next;
    bool operator < (const KSD &a)const
    {return v==a.v?next<a.next:v<a.v;}
}e[N],E[N],rd[N];
int head[N],HEAD[N],cnt;
inline void add(int u,int v)
{
    e[++cnt].v=v;
    e[cnt].next=head[u];
    head[u]=cnt;
}
inline void Add(int u,int v)
{
    e[++cnt].v=v;
    E[cnt].v=u;
    e[cnt].next=head[u];
    E[cnt].next=HEAD[v];
    HEAD[v]=head[u]=cnt;
}
 // 缩点
bool de[N];
int num[N],n,m;
struct Tarjan_2_3_3_3
{
    int dfn[N],cnt,vis[N],id[N];
    void dfs1(int x)
    {
        vis[x]=1;int i,v;
        for(i=head[x];i;i=e[i].next)
            if(!vis[v=e[i].v])dfs1(v);
        dfn[++cnt]=x;
    }
    void dfs2(int x,int group)
    {
        int i,v;
        id[x]=group;
        for(i=HEAD[x];i;i=E[i].next)
            if(!id[v=E[i].v])dfs2(v,group);
    }
    void work(int n)
    {
        // kosaraju
        for(int i=1;i<=n;i++)if(!vis[i])dfs1(i);
        for(int i=n;i;i--)if(!id[dfn[i]])
            dfs2(dfn[i],dfn[i]);
        for(int i=1;i<=n;i++)num[id[i]]++;
        // 去重边
        for(int i=1;i<=m;i++)
        {
            rd[i].v=id[rd[i].v];
            rd[i].next=id[rd[i].next];
        }
        sort(rd+1,rd+m+1);
        for(int i=1;i<=m;i++)
        {
            if(rd[i].v==rd[i-1].v&&rd[i].next==rd[i-1].next)de[i]=1;
            else if(rd[i].v==rd[i].next)de[i]=1;
        }

    }
}suodian;
bool vis1[N],vis2[N];
 // 判断1能到哪些点，哪些点能到1
void dfs1(int x)
{
    vis1[x]=1;
    int i,v;
    for(i=head[x];i;i=e[i].next)
    {
        if(vis1[v=e[i].v])continue;
        dfs1(v);
    }
}
void dfs2(int x)
{
    vis2[x]=1;
    int i,v;
    for(i=HEAD[x];i;i=E[i].next)
    {
        if(vis2[v=E[i].v])continue;
        dfs2(v);
    }
}
int f1[N],f2[N],d[N];
queue<int>q;
int main()
{
    freopen("test1.in","r",stdin);
    int i,j,k;
    int a,b;
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&rd[i].v,&rd[i].next);
        Add(rd[i].v,rd[i].next);
    }
    dfs1(1),dfs2(1);
    suodian.work(n);
    // 处理1能到的点
    memset(head,0,sizeof head),cnt=0;
    memset(d,0,sizeof d);
    for(i=1;i<=m;i++)if(!de[i])
    {
        a=rd[i].v,b=rd[i].next;
        if(vis1[a]&vis1[b])add(a,b),d[b]++;
    }
    while(!q.empty())q.pop();
    q.push(1);
    while(!q.empty())
    {
        a=q.front(),q.pop();
        f1[a]+=num[a];
        for(i=head[a];i;i=e[i].next)
        {
            d[b=e[i].v]--;
            f1[b]=max(f1[b],f1[a]);
            if(!d[b])q.push(b);
        }
    }
    // 处理能到1的点
    memset(head,0,sizeof head),cnt=0;
    memset(d,0,sizeof d);
    for(i=1;i<=m;i++)if(!de[i])
    {
        a=rd[i].v,b=rd[i].next;
        if(vis2[a]&vis2[b])add(b,a),d[a]++;
    }
    while(!q.empty())q.pop();
    q.push(1);
    while(!q.empty())
    {
        a=q.front(),q.pop();
        f2[a]+=num[a];
        for(i=head[a];i;i=e[i].next)
        {
            d[b=e[i].v]--;
            f2[b]=max(f2[b],f2[a]);
            if(!d[b])q.push(b);
        }
    }
    // 枚举边
    int ans=2*num[1];
    for(i=1;i<=m;i++)if(!de[i])
    {
        a=rd[i].next,b=rd[i].v;
        if(vis1[a]&&vis2[b])
            ans=max(ans,f1[a]+f2[b]);
    }
    printf("%d\n",ans-num[1]);
    return 0;
}