[补档][Usaco2015 Jan]Grass Cownoisseur

[Usaco2015 Jan]Grass Cownoisseur

题目

给一个有向图，然后选一条路径起点终点都为1的路径出来，有一次机会可以沿某条边逆方向走，问最多有多少个点可以被经过？

（一个点在路径中无论出现多少正整数次对答案的贡献均为1）

INPUT

The first line of input contains N and M, giving the number of fields and the number of one-way paths (1 <= N, M <= 100,000). The following M lines each describe a one-way cow path. Each line contains two distinct field numbers X and Y, corresponding to a cow path from X to Y. The same cow path will never appear more than once.

N个点，M条有向边，无重边

OUTPUT

A single line indicating the maximum number of distinct fields Bessie

can visit along a route starting and ending at field 1, given that she can

follow at most one path along this route in the wrong direction.

SAMPLE

INPUT

7 10

1 2

3 1

2 5

2 4

3 7

3 5

3 6

6 5

7 2

4 7

OUTPUT

6

解题报告

这道题考试的时候，一看就知道是tarjan，然后就真的傻傻的打了个tarjan+dfs，就A了一个点= =

正解：

tarjan缩点，因为可以逆转一条边，而同一强连通分量里的边逆转是没啥用的，所以我们可以枚举缩点后的边。

首先，跑2遍SPFA，一遍缩点后的正边，一遍反边，处理出正反两个最大的经过权值（每点权值为缩点后强连通分量的点数）。

剩下的就很简单了，思考当一条有向边反过来时，它反边的起点走的是正向的最大权值，而终点则走的是反向的最大权值，那么我们枚举每一条边，两权相加求max即为答案。

注意：特判，两边SPFA若有一遍没有联通这条边对应的强连通分量，这个点就不能跑。

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;
 inline int read(){
     int sum();
     char ch(getchar());
     while(ch<''||ch>'')
         ch=getchar();
     while(ch>=''&&ch<=''){
         sum=sum*+ch-'';
         ch=getchar();
     }
     return sum;
 }
 struct edge{
     int s,e,n;
 }k[],a[],b[];
 int pre[],tot;
 inline void insert(int s,int e){
     k[++tot].s=s;
     k[tot].e=e;
     k[tot].n=pre[s];
     pre[s]=tot;
 }
 int low[],dfn[],stack[],bl[],size[];
 int head,cnt,qlt;
 bool vis[];
 inline int my_min(int a,int b){
     return a<b?a:b;
 }
 inline int my_max(int a,int b){
     return a>b?a:b;
 }
 inline void tarjan(int u){
     low[u]=dfn[u]=++cnt;
     vis[u]=;
     stack[++head]=u;
     for(int i=pre[u];i!=-;i=k[i].n){
         int e(k[i].e);
         if(!dfn[e]){
             tarjan(e);
             low[u]=my_min(low[u],low[e]);
         }
         else
             if(vis[e])
                 low[u]=my_min(low[u],dfn[e]);
     }
     if(low[u]==dfn[u]){
         int tmp;
         qlt++;
         while(){
             tmp=stack[head--];
             bl[tmp]=qlt;
             vis[tmp]=;
             if(tmp==u)
                 break;
         }
     }
 }
 int adj[],num;
 inline void add(int s,int e){
     a[++num].s=s;
     a[num].e=e;
     a[num].n=adj[s];
     adj[s]=num;
 }
 queue<int>q;
 int fz[];
 inline void spfa1(int x){
     memset(vis,,sizeof(vis));
     memset(fz,,sizeof(fz));
     q.push(x);
     fz[x]=size[x];
     vis[x]=;
     while(!q.empty()){
         int k(q.front());
         q.pop();
         for(int i=adj[k];i!=-;i=a[i].n){
             int e(a[i].e);
             if(fz[e]<fz[k]+size[e]){
                 fz[e]=fz[k]+size[e];
                 if(!vis[e]){
                     q.push(e);
                     vis[e]=;
                 }
             }
         }
         vis[k]=;
     }
 }
 int hhh,nxt[];
 inline void init(int s,int e){
     b[++hhh].s=s;
     b[hhh].e=e;
     b[hhh].n=nxt[s];
     nxt[s]=hhh;
 }
 int ff[];
 inline void spfa2(int x){
     memset(vis,,sizeof(vis));
     memset(ff,,sizeof(ff));
     q.push(x);
     ff[x]=size[x];
     vis[x]=;
     while(!q.empty()){
         int k(q.front());
         q.pop();
         for(int i=nxt[k];i!=-;i=b[i].n){
             int e(b[i].e);
             if(ff[e]<ff[k]+size[e]){
                 ff[e]=ff[k]+size[e];
                 if(!vis[e]){
                     q.push(e);
                     vis[e]=;
                 }
             }
         }
         vis[k]=;
     }
 }
 inline int find(int x){
     int s(a[x].e),e(a[x].s);
     if(!fz[s]||!ff[e])
         return ;
     return fz[s]+ff[e]-size[bl[]];
 }
 int n,m;
 int main(){
     memset(pre,-,sizeof(pre));
     memset(adj,-,sizeof(adj));
     memset(nxt,-,sizeof(nxt));
     n=read(),m=read();
     for(int i=;i<=m;i++){
         int x(read()),y(read());
         insert(x,y);
     }
     for(int i=;i<=n;i++)
         if(!dfn[i])
             tarjan(i);
     for(int i=;i<=n;i++)
         size[bl[i]]++;
     for(int i=;i<=tot;i++){
         int s(k[i].s),e(k[i].e);
         if(bl[s]!=bl[e])
             add(bl[s],bl[e]),init(bl[e],bl[s]);
     }
     spfa1(bl[]);
     spfa2(bl[]);
     int ans();
     for(int i=;i<=num;i++)
         ans=my_max(ans,find(i));
     printf("%d\n",ans);
 }

ps:调了我两个小时，最后发现重新建边的时候我用的原来点的编号，没有用缩完点后的编号，然后就听取蛙声一片了= =