Tarjan水题系列(1):草鉴定Grass Cownoisseur [USACO15JAN]or[luogu P3119]

题目如下:

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

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

大意:

求一个有向图在走一次反向边或不走的情况下走的节点数最多的回到起点的路径的节点数

思路：

首先边可以重复走 所以缩点不会影响答案

缩点后得到的是一个DAG 我们有走一次反向边的机会 此时就相当于在DAG上加一条边 由于要从起点回到起点 这加的一条边的两端要满足一端起点能够到达 一端能通往起点

说到这里算法已经显而易见了 故不赘述了

下面是代码：

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 #include <memory.h>
 #define r(x) x=read()
 #define MAXX 100005
 #define MIN(a,b) (a<b?a:b)
 #define MAX(a,b) (a>b?a:b)
 using namespace std;
 int h[MAXX],h2[MAXX],cnt,dis[][MAXX],flag[MAXX];
 int dfn[MAXX],low[MAXX],id[MAXX],w[MAXX],k,top,sta[MAXX],num;
 int n,m,ans,ans2,u,to,st;
 struct edge{int to,nex;}e[MAXX],yuan[MAXX];
 void add(int u,int to)
 {
   cnt++;
   e[cnt]=(edge){to,h[u]},h[u]=cnt;
 }
 void tarjan(int now)
 {
   sta[++top]=now;
   dfn[now]=low[now]=++k;
   for(int i=h[now];i;i=e[i].nex)
   {
     if(!dfn[e[i].to])
       tarjan(e[i].to),low[now]=MIN(low[now],low[e[i].to]);
     else
       if(!id[e[i].to])
         low[now]=MIN(low[now],dfn[e[i].to]);
   }
   if(low[now]==dfn[now])
   {
     id[now]=++num;
     while(sta[top]!=now){id[sta[top]]=num;top--;}
     top--;
   }
 }
 void spfa(int now,int x)
 {
   queue<int>que;
   dis[x][now]=w[now];
   que.push(now);
   flag[now]=;
   while(!que.empty())
   {
     int p=que.front();que.pop();
     for(int i=h[p];i;i=e[i].nex)
     {
       if(i%!=x) continue;
       if(dis[x][e[i].to]<dis[x][p]+w[e[i].to])
       {
         dis[x][e[i].to]=dis[x][p]+w[e[i].to];
         if(!flag[e[i].to])
           flag[e[i].to]=,que.push(e[i].to);
       }
     }
     flag[p]=;
   }
 }
 void dfs(int now)
 {
   for(int i=h[now];i;i=e[i].nex)
   {
     int to=e[i].to;
     if(i%==)
     {
       if(dis[][now]&&dis[][to])
         ans=MAX(ans,dis[][now]+dis[][to]);
     }
     else
       dfs(to);
   }
 }
 bool cmp(edge a,edge b)
 {
   return id[a.to]==id[b.to]?id[a.nex]<id[b.nex]:id[a.to]<id[b.to];
 }
 int read()
 {
   char ch=;int w=;
   while(ch<''||ch>''){ch=getchar();}
   while(ch>=''&&ch<=''){w=w*+ch-'';ch=getchar();}
   return w;
 }
 int main()
 {
   r(n),r(m);
   for(int i=;i<=m;++i)
     r(u),r(to),add(u,to),yuan[i]=(edge){to,u};
   for(int i=;i<=n;++i)
     if(!dfn[i])
       tarjan(i);
   for(int i=;i<=n;++i)
     w[id[i]]++;
   st=id[];
   sort(yuan+,yuan+m+,cmp);
   memset(h,,sizeof(h));
   cnt=;
   for(int i=;i<=m;++i)
   {
     int x=id[yuan[i].nex],y=id[yuan[i].to];
     if((x==id[yuan[i-].nex]&&y==id[yuan[i-].to])||(x==y))
       continue;
     add(x,y),add(y,x);
   }
   spfa(st,),spfa(st,);
   ans=w[st];
   dfs(st);
   if(ans>w[st]) printf("%d",ans-w[st]);
   else printf("%d",ans);
   return ;
 }