【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=100000+50;
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[1]]=size[col[1]];
    for (int i=1;i<=colcnt;i++)
        if (!degree1[i]) que.push(i);
    while (!que.empty())
    {
        int now=que.front();que.pop();
        for (int i=0;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[1]]=size[col[1]];
    for (int i=1;i<=colcnt;i++)
        if (!degree2[i]) que.push(i);
    while (!que.empty())
    {
        int now=que.front();que.pop();
        for (int i=0;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]=1;
    S.push(u);
    for (int i=0;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]==1) low[u]=min(low[u],dfn[v]);
    }
    
    if (dfn[u]==low[u])
    {
        colcnt++;
        int x;
        do
        {
            x=S.top();
            col[x]=colcnt;
            instack[x]=2;
            size[colcnt]++;
            S.pop();
        }while (x!=u);
    }
}

void init()
{
    scanf("%d%d",&n,&m);
    for (int i=0;i<m;i++) 
    {
        scanf("%d%d",&x[i],&y[i]);
        E[x[i]].push_back(y[i]);
    }
    memset(instack,0,sizeof(instack));
    cnt=colcnt=0;
    for (int i=1;i<=n;i++)
        if (!instack[i]) tarjan(i);
    for (int i=0;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,0,sizeof(dis));
    memset(rdis,0,sizeof(rdis));
    Topology1();
    Topology2();
    int ans=-1;
    for (int i=0;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[1]);
}

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