旅行家

【问题描述】

　　在A国有n个城市，编号1到n，这些城市由若干条单行道路相连。小沐是一个旅行家，他想在他有生之年，到尽可能多的城市去旅游。
　　小沐总是从他的家乡——1号城市出发，最后再回到1号城市。他想经过尽可能多的城市，小沐可以经过一个城市多次。因为城市间是单行道连接，这给小沐的旅行带来了很大的不便，因此，小沐想偷偷逆向行走一次，但最多只能有一次逆行。
　　问，小沐最多能经过多少个不同的城市。

【输入格式】

　　输入的第一行包含两个整数n和m，表示A国的城市数目和道路数量。接下来的m行，表示m条单向道路，每条道路连接城市u和v，表示从u出发到达v。

【输出格式】

　　仅输出一个整数，表示所求答案。

【输入样例】

7 10
1 2
3 1
2 5
2 4
3 7
3 5
3 6
6 5
7 2
4 7

【输出样例】

6

【样例解释】

小沐行走线路是1, 2, 4, 7, 2, 5, 3, 1 ，在5到3的时候逆行了一次。

【数据范围】

1<=N,M<=100000
思路
很显然的强连通分量。某大佬给我说这道题自己想出来的话强连通分量缩点基本没问题了。其实可以算套路题，缩点后即为DAG图，唯一的难点在于他会逆向走一次。这时候会发现如果反向走回到1就会形成一个环，于是DAG上的动态规划就转化为了两个，正向图和反向图上的
代码如下

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cctype>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;
#define maxn 100005
#define maxm 100005
typedef long long LL;
int first[maxn],np=0,belong[maxn],dfn[maxn],low[maxn],DFS_clock=0,scc;
int stk[maxn],top=0,n,m,dist1[maxn],dist2[maxn],sz[maxn],rd1[maxn],rd2[maxn];
bool vis[maxn];
vector<int>g1[maxn],g2[maxn];
const int inf=3e8;
struct edge
{
    int to,next;
}e[maxm<<1];
void addedge(int u,int v)
{
    e[++np]=(edge){v,first[u]};
    first[u]=np;
}
void init()
{
    int u,v;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&u,&v);
        addedge(u,v);
    }
}
void tarjan(int i)
{
    vis[i]=1;
    low[i]=dfn[i]=++DFS_clock;
    stk[++top]=i;
    for (int p=first[i];p;p=e[p].next)
    {
        int j=e[p].to;
        if (vis[j])
        {
            if (!belong[j])
            low[i]=min(low[i],dfn[j]);
            continue;
        }
        tarjan(j);
        low[i]=min(low[i],low[j]);
    }
    if (low[i]==dfn[i])
    {
        scc++;
        while(1)
        {
            int x=stk[top--];
            belong[x]=scc;
            sz[scc]++;
            if (x==i)
            break;
        }
    }
}
void find_scc()
{
    memset(vis,0,sizeof(vis));
    memset(belong,0,sizeof(belong));
    for (int i=1;i<=n;i++)
    if (!vis[i])
    tarjan(i);
}
void suodian()
{
    find_scc();
    for (int i=1;i<=n;i++)
    for (int p=first[i];p;p=e[p].next)
    {
        int j=e[p].to;
        if (belong[i]!=belong[j])
        {
            g1[belong[i]].push_back(belong[j]);
            rd1[belong[j]]++;
            g2[belong[j]].push_back(belong[i]);
            rd2[belong[i]]++;
        }
    }
}
int dp1(int i)
{
    if (dist1[i]!=-1)
    return dist1[i];
    int t;
    if (i==belong[1])
    t=0;
    else
    t=-inf;
    for (int k=0;k<g1[i].size();k++)
    {
        int j=g1[i][k];
        t=max(t,dp1(j));
    }
    dist1[i]=t+sz[i];
    return dist1[i];
}
int dp2(int i)
{
    if (dist2[i]!=-1)
    return dist2[i];
    int t;
    if (i==belong[1])
    t=0;
    else
    t=-inf;
    for (int k=0;k<g2[i].size();k++)
    {
        int j=g2[i][k];
        t=max(t,dp2(j));
    }
    dist2[i]=t+sz[i];
    return dist2[i];
}
void solve()
{
    int ans=0;
    suodian();
    memset(dist1,-1,sizeof(dist1));
    memset(dist2,-1,sizeof(dist2));
    for (int i=1;i<=scc;i++)
    if (rd1[i]==0&&dist1[i]==-1)
    dp1(i);
    for (int i=1;i<=scc;i++)
    if (rd2[i]==0&&dist2[i]==-1)
    dp2(i);
    for (int i=1;i<=scc;i++)
    for (int k=0;k<g1[i].size();k++)
    {
        int j=g1[i][k];
        ans=max(ans,dist1[i]+dist2[j]-sz[belong[1]]);
    }
    printf("%d",ans);
}
int main()
{
    //freopen("in.txt","r",stdin);
    init();
    solve();
    return 0;
}