zoj3795 Grouping DP+强连通

     N个人M种单向关系，有直接或间接关系的两人不能分在同一组，问最少需要分成多少组可以满足要求？首先一个强连通分量里的任意两人是不能分同一组的，其次，所有可以通到该强连通分量的点，和可以从该强连通分量出发到达的点，也是不能分在一组的，而这恰好就是图中的一条路径，那么问题就变成了强连通所点后，在有向无环图中找一条点最多的路径，这条路径上的点是不能分在同一组的，所以至少就需要这么多点个分组。

      DP的时候先写成了BFS居然MLE...改成DFS才给过...

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn=100000+100;
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
vector<int> G[maxn];
vector<int> g[maxn];
int size[maxn];
void dfs(int u)
{
    pre[u]=lowlink[u]=++dfs_clock;
    S.push(u);
    for (int i=0; i<G[u].size(); i++)
    {
        int v=G[u][i];
        if (!pre[v])
        {
            dfs(v);
            lowlink[u]=min(lowlink[u],lowlink[v]);
        }
        if (!sccno[v])
        {
            lowlink[u]=min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u]==pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x=S.top();
            S.pop();
            sccno[x]=scc_cnt;
            if (x==u) break;
        }
    }
}
void find_scc(int n)
{
    dfs_clock=scc_cnt=0;
    memset(sccno,0,sizeof sccno);
    memset(pre,0,sizeof pre);
    for (int i=0; i<n; i++)
    {
        if (!pre[i]) dfs(i);
    }
}
int in[maxn],out[maxn];
int n,m;
int dp[maxn];

void find(int x)
{
   if (dp[x]!=-1) return ;
   dp[x]=size[x];
   for (int i=0; i<g[x].size(); i++)
   {
       int v=g[x][i];
       find(v);
       dp[x]=max(dp[x],dp[v]+size[x]);
   }

}
int main()
{
//    freopen("in.txt","r",stdin);
    int x,y;
    while(~scanf("%d%d",&n,&m))
    {
        for (int i=0; i<=n; i++)
        G[i].clear(),g[i].clear();

        for (int i=0; i<m; i++)
        {
            scanf("%d%d",&x,&y);
            x--;
            y--;
            G[x].push_back(y);
        }
        find_scc(n);
        memset(size,0,sizeof size);
        for (int i=0; i<n; i++)
        {
            size[sccno[i]]++;
        }
        memset(in,0,sizeof in);
        for (int i=0; i<n; i++)
        {
            int u,v;
            for (int j=0; j<G[i].size(); j++)
            {
                u=sccno[i];
                v=sccno[G[i][j]];
                if (u!=v)
                {
                    in[v]++;
                    g[u].push_back(v);
                }
            }
        }
        memset(dp,-1,sizeof dp);
        int ans=0;
        for (int i=1; i<=scc_cnt; i++)
        {
            if (dp[i]==-1) find(i);
            ans=max(ans,dp[i]);
        }
        cout<<ans<<endl;
    }
    return 0;
}