USACO 2015 January Contest Gold T3: Grass Cownoisseur

题目大意

约翰有n块草场，编号1到n，这些草场由若m条单行道相连。奶牛贝西是美味牧草的鉴赏家，她想到达尽可能多的草场去品尝牧草。(1 <= n, m <= 100,000).

贝西总是从1号草场出发，最后回到1号草场。她想经过尽可能多的草场，贝西在通过一个草场时只能吃一次草，但一个草场可以经过多次。因为草场是单行道连接，这给贝西的品鉴工作带来了很大的不便，贝西想偷偷逆向行走一次，但最多只能有一次逆行。问，贝西最多能吃到多少个草场的牧草。

题目分析

观察“在通过一个草场时只能吃一次草，但一个草场可以经过多次”，很明显可以看出我们要把相互可以到达的点缩成一个点，这里用Tarjan实现即可。

缩点后建出新图，这时从 点1所在强连通分量 所开始跑一遍最短（长）路即可得出没有“逆行”这个条件时的答案。所得结果即为dis1[N]。

考虑如何处理逆行。因为贝西最后要回到1号草场，所以我们不妨再反向建一次边，得出以 点1所在强连通分量 为终点的所有最短（长）路。所得结果即为dis2[N]。

然后我们就可以枚举一个 强连通分量x 通过反边找出它可以逆行一次到达的 强连通分量 y, 然后就可以更新答案了。

注意 点1所在强连通分量 在作为起点和终点时都被计算了一次，所以要减掉 点1所在强连通分量 内的点数。

化为代码，就是 ans = max( ans, dis1[now] + dis2[y] - tot[bcc[1]] );

#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e5+10;
const int MAXM=1e5+10;

struct Edge{
    int to,nxt;
}oe[MAXM],e1[MAXM],e2[MAXM];
int cnt,cnt1,cnt2;
int head[MAXN],head1[MAXN],head2[MAXN];
inline void add_edge(int u,int v){oe[++cnt].to=v;oe[cnt].nxt=head[u];head[u]=cnt;}
inline void add_edge1(int u,int v){e1[++cnt1].to=v;e1[cnt1].nxt=head1[u];head1[u]=cnt1;}
inline void add_edge2(int u,int v){e2[++cnt2].to=v;e2[cnt2].nxt=head2[u];head2[u]=cnt2;}

int n,m;

int col,c[MAXN],bcc[MAXN],tot[MAXN];
int tim,dfn[MAXN],low[MAXN];
int top,st[MAXN];
bool insta[MAXN];

bool vis[MAXN];
int dis1[MAXN],dis2[MAXN];
inline void Tarjan(int x){
    dfn[x]=low[x]=++tim;
    st[++top]=x;insta[x]=true;
    for(int i=head[x],y;i;i=oe[i].nxt){
        y=oe[i].to;
        if(!dfn[y]){
            Tarjan(y);
            low[x]=min(low[x],low[y]);
        }
        else if(insta[y])
            low[x]=min(low[x],low[y]);
    }
    if(low[x]==dfn[x]){
        bcc[x]=++col;insta[x]=false;
        tot[col]++;
        while(st[top]!=x){
            ++tot[col];
            insta[st[top]]=false;
            bcc[st[top--]]=col;
        }
        --top;
    }
}

inline void SPFA1(int S){
    memset(vis,0,sizeof(vis));
    dis1[S]=tot[S];
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int x=q.front();q.pop();
        vis[x]=false;
        for(int i=head1[x],y;i;i=e1[i].nxt){
            y=e1[i].to;
            if(dis1[y]<dis1[x]+tot[y]){
                dis1[y]=dis1[x]+tot[y];
                if(!vis[y]){
                    q.push(y);
                    vis[y]=true;
                }
            }
        }
    }
}
inline void SPFA2(int S){
    memset(vis,0,sizeof(vis));
    dis2[S]=tot[S];
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int x=q.front();q.pop();
        vis[x]=false;
        for(int i=head2[x],y;i;i=e2[i].nxt){
            y=e2[i].to;
            if(dis2[y]<dis2[x]+tot[y]){
                dis2[y]=dis2[x]+tot[y];
                if(!vis[y]){
                    q.push(y);
                    vis[y]=true;
                }
            }
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1,u,v;i<=m;++i){
        scanf("%d%d",&u,&v);
        add_edge(u,v);
    }
    for(int i=1;i<=n;++i)
        if(!dfn[i])
            Tarjan(i);
    for(int x=1;x<=n;++x)
        for(int i=head[x],y;i;i=oe[i].nxt){
            y=oe[i].to;
            if(bcc[x]!=bcc[y]){
                add_edge1(bcc[x],bcc[y]);
                add_edge2(bcc[y],bcc[x]);
            }
        }
    SPFA1(bcc[1]);
    SPFA2(bcc[1]);
    int ans=tot[bcc[1]];
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;++i){
        if(!vis[bcc[i]]&&dis1[bcc[i]]){
            int now=bcc[i];
            vis[now]=1;
            for(int j=head2[now],y;j;j=e2[j].nxt){
                y=e2[j].to;
                if(!dis2[y]) continue;
                ans=max(ans,dis1[now]+dis2[y]-tot[bcc[1]]);
            } 
        }
    }
    printf("%d
",ans);
    return 0;
}