[USACO15JAN]草鉴定Grass Cownoisseur 题解

题目大意：有n个点，有一只牛从1号点出发，最后要走回1号点，可以逆行一次，要使得路径上经过的不同的点最多，问最多能经过多少个不同的点。

首先可以发现，假如它走到了一个环里面，那么它一定是可以走完环内所有点的，并且可以从环内任意一个点出发继续向下走，那么首先可以先缩点，那么缩完点之后的图是一定没有环的，就是说你从一号点出发之后就一定走不回来了，那么这个时候就要用到逆行了，我们只要枚举缩完点后的图中的边，尝试着逆行这条边，看看最多能经过多少个点，记录最大值就好了，但是如果每一次都跑一遍spfa肯定超时，所以我们可以预处理出1到每个点的最大距离以及每个点到1的最大距离，那这样子每一次逆行所能经过的点数都可以O(1)求出。

代码如下：

#include <cstdio>
#include <cstring>

int dfn[100010],low[100010];
int belong[100010],cnt=0;
int n,m,len=0,lenn=0;
struct node{int x,y,next;};
node e[100010],ee[100010];
int first[100010];
void buildroad(int x,int y)//这是没缩点时的
{
    len++;
    e[len].x=x;
    e[len].y=y;
    e[len].next=first[x];
    first[x]=len;
}
void buildotherroad(int x,int y)//这是缩点后的
{
    lenn++;
    ee[lenn].x=x;
    ee[lenn].y=y;
    ee[lenn].next=first[x];
    first[x]=lenn;
}
int tot=0;
int zhan[100010],t=0;
bool v[100010];
int size[100010];
int minn(int x,int y){return x<y?x:y;}
void dfs(int x)//强连通缩点
{
    zhan[++t]=x;
    dfn[x]=low[x]=++tot;
    v[x]=true;
    for(int i=first[x];i;i=e[i].next)
    {
        int y=e[i].y;
        if(!dfn[y])
        {
            dfs(y);
            low[x]=minn(low[x],low[y]);
        }
        else if(v[y])low[x]=minn(low[x],dfn[y]);
    }
    if(dfn[x]==low[x])
    {
        int xx;cnt++;
        do
        {
            size[cnt]++;
            xx=zhan[t--];
            v[xx]=false;
            belong[xx]=cnt;//belong表示每个点属于哪个强连通分量
        }while(xx!=x);
    }
}
int q[100010];
int dis[2][100010];
void spfa(int id)
{
    int st=1,ed=2;
    q[st]=belong[1];
    memset(v,false,sizeof(v));
    v[q[st]]=true;
    dis[id][belong[1]]=0;//我这里初始化成0，也就是我少算了size[1]，但是我会在下面加上
    					//如果这里改成size[1]的话，下面就要减掉size[1]，想想为什么 
    while(st!=ed)
    {
        int x=q[st];
        for(int i=first[x];i;i=ee[i].next)
        {
            int y=ee[i].y;
            if(dis[id][y]<dis[id][x]+size[y])//注意这里要加size[y]，size表示这个点是多少个点缩成的
            {
                dis[id][y]=dis[id][x]+size[y];
                if(!v[y])
                {
                	v[y]=true;
                	q[ed++]=y;
                }
            }
        }
        st++;
        v[x]=false;
    }
}
void go(int x)//预处理出1到每个点的最大距离以及每个点到1的最大距离，1到每个点的最大距离直接跑一次spfa，每个点到1的距离就把所有边反过来再跑一边就好了
{
    lenn=0;
    memset(first,0,sizeof(first));
    for(int i=1;i<=len;i++)
    if(belong[e[i].x]!=belong[e[i].y])
    {
        if(!x)buildotherroad(belong[e[i].x],belong[e[i].y]);
        else buildotherroad(belong[e[i].y],belong[e[i].x]);
    }
    spfa(x);
}
int main()
{
    scanf("%d %d",&n,&m);
    memset(first,0,sizeof(first));
    memset(dis,-1,sizeof(dis));
    memset(size,0,sizeof(size));
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d %d",&x,&y);
        buildroad(x,y);
    }
    memset(dfn,0,sizeof(dfn));
    memset(v,false,sizeof(v));
    for(int i=1;i<=n;i++)
    if(dfn[i]==0)dfs(i);
    go(1);go(0);//1是求每个点到1，0是1到每个点，注意go(1)和go(0)不能互换，因为go(0)跑的时候用的才是正常的图，而这幅图下面还用得到
    int ans=0;
    for(int i=1;i<=lenn;i++)
    {
        int x=ee[i].x,y=ee[i].y;//x，y原本表示这条边的起点和终点，但我们要把枚举的边反过来，所以在这里y是起点x是终点 
        if(dis[0][y]!=-1&&dis[1][x]!=-1&&dis[0][y]+dis[1][x]+size[belong[1]]>ans)//假如1能够到达y并且x能够到达1，就用他们路径上的总点数尝试更新ans 
        ans=dis[0][y]+dis[1][x]+size[belong[1]];
    }
    printf("%d",ans);
}