uva11324 有向图的强连通分量+记忆化dp

给一张有向图G， 求一个结点数最大的结点集，使得该结点集中任意两个结点u和v满足，要么u可以到达v， 要么v可以到达u（u和v相互可达也可以）。

因为整张图可能存在环路，所以不好使用dp直接做，先采用有向图的强连通分量，进行缩点，然后得到一个有向无环图(DAG) 在采用记忆话dp 去做即可

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#include <vector>
#include <stack>
using namespace std;
const int maxn = +;
vector<int>G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
void dfs(int u){
    pre[u] = lowlink[u]=++dfs_clock;
    S.push(u);
    for(int i=; i<G[u].size() ; ++i){
         int v = G[u][i];
         if(!pre[v]){
             dfs(v);
             lowlink[u] = min(lowlink[u], lowlink[v]);
         }else 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 =;
     memset(sccno,,sizeof(sccno));
     memset(pre, , sizeof(pre));
     while(!S.empty())S.pop();
     for(int i=; i<n; ++i)
        if(!pre[i]) dfs(i);
}
int value[maxn],dp[maxn];
vector<int> E[maxn];
int dff(int u){
    if(dp[u]!=-) return dp[u];
     dp[u]=;
    for(int i=; i<E[u].size(); ++i){
         int v = E[u][i];
         dp[u]=max(dff(v),dp[u]);
    }
    dp[u]+=value[u];
    return dp[u];
}
int main()
{
     int cas;
     scanf("%d",&cas);
     for(int cc =; cc<=cas; ++cc){

           int n,m;
           scanf("%d%d",&n,&m);
           for(int i=; i<=n; ++i)
            G[i].clear(),E[i].clear();
           for(int i=; i<=m; ++i){
               int u,v;
               scanf("%d%d",&u,&v);
               u--; v--;
               G[u].push_back(v);
           }
           find_scc(n);
           memset(value,,sizeof(value));
           for(int u=; u<n; ++u){
                value[sccno[u]]++;
                for(int j=; j<G[u].size(); ++j){
                     int v=G[u][j];
                     if(sccno[u]!=sccno[v]){
                          E[sccno[u]].push_back(sccno[v]);
                     }
                }
           }
           memset(dp , - , sizeof(dp));
           int ans=;
           for(int i=; i <= scc_cnt; ++i){
                if(dp[i]==-)
                 dff(i);
                 ans=max(ans,dp[i]);
           }
           printf("%d\n",ans);
     }
    return ;
}