【tarjan+拓扑】BZOJ3887-[Usaco2015 Jan]Grass Cownoisseur

【题目大意】

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

【思路】

首先缩点，对于每一个联通块求出正图和反图中节点1所在的联通块到它的最长节点数。这个用拓扑排序处理一下。

枚举每一条边取反，对于边(u,v),其取反后的距离就等于dis[u所在的联通快]+dis[v所在的联通块]-dis[1所在的联通块]（因为会被重复计算不要忘记减去）

我一开始非常脑抽地在想会不会发生这样的情况：本来到u所在的联通块就会经过v,这样不就重复计算点了。要注意缩点之后的图为DAG，如果存在v->u的路径，同时存在u->v的路径，那么必定存在环，矛盾。

【错误点】

写x节点所在的联通块的时候，一直写成x节点。千万不要忘记了col[]。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<stack>
 #include<queue>
 using namespace std;
 const int MAXN=+;
 vector<int> E[MAXN];
 vector<int> tE[MAXN],rtE[MAXN];
 stack<int> S;
 int x[MAXN],y[MAXN];
 int instack[MAXN],low[MAXN],dfn[MAXN],col[MAXN],size[MAXN],cnt,colcnt;
 int dis[MAXN],rdis[MAXN],degree1[MAXN],degree2[MAXN];
 int vis[MAXN];
 int n,m;

 void Topology1()
 {
     memset(dis,0xef,sizeof(dis));//初始化为-INF
     queue<int> que;
     dis[col[]]=size[col[]];
     for (int i=;i<=colcnt;i++)
         if (!degree1[i]) que.push(i);
     while (!que.empty())
     {
         int now=que.front();que.pop();
         for (int i=;i<tE[now].size();i++)
         {
             int to=tE[now][i];
             dis[to]=max(dis[to],dis[now]+size[to]);
             if (!--degree1[to]) que.push(to);
         }
     }
 }

 void Topology2()
 {
     memset(rdis,0xef,sizeof(rdis));
     queue<int> que;
     rdis[col[]]=size[col[]];
     for (int i=;i<=colcnt;i++)
         if (!degree2[i]) que.push(i);
     while (!que.empty())
     {
         int now=que.front();que.pop();
         for (int i=;i<rtE[now].size();i++)
         {
             int to=rtE[now][i];
             rdis[to]=max(rdis[to],rdis[now]+size[to]);
             if (!--degree2[to]) que.push(to);
         }
     }
 }

 void tarjan(int u)
 {
     dfn[u]=low[u]=++cnt;
     instack[u]=;
     S.push(u);
     for (int i=;i<E[u].size();i++)
     {
         int v=E[u][i];
         if (!instack[v])
         {
             tarjan(v);
             low[u]=min(low[u],low[v]);

         }
         else if (instack[v]==) low[u]=min(low[u],dfn[v]);
     }

     if (dfn[u]==low[u])
     {
         colcnt++;
         int x;
         do
         {
             x=S.top();
             col[x]=colcnt;
             instack[x]=;
             size[colcnt]++;
             S.pop();
         }while (x!=u);
     }
 }

 void init()
 {
     scanf("%d%d",&n,&m);
     for (int i=;i<m;i++)
     {
         scanf("%d%d",&x[i],&y[i]);
         E[x[i]].push_back(y[i]);
     }
     memset(instack,,sizeof(instack));
     cnt=colcnt=;
     for (int i=;i<=n;i++)
         if (!instack[i]) tarjan(i);
     for (int i=;i<m;i++)
     {
         if (col[x[i]]!=col[y[i]])
         {
             tE[col[x[i]]].push_back(col[y[i]]);
             degree1[col[y[i]]]++;
             rtE[col[y[i]]].push_back(col[x[i]]);
             degree2[col[x[i]]]++;
         }
     }
 }

 void solve()
 {
     memset(dis,,sizeof(dis));
     memset(rdis,,sizeof(rdis));
     Topology1();
     Topology2();
     int ans=-;
     for (int i=;i<m;i++)
     {
         ans=max(ans,dis[col[x[i]]]+rdis[col[y[i]]]);//注意这里是col[x[i]]不要写成x[i]了
         ans=max(ans,rdis[col[x[i]]]+dis[col[y[i]]]);
     }
     printf("%d",ans-size[]);
 }

 int main()
 {
     init();
     solve();
     return ;
 }