uvaoj 11324 - The Largest Clique

题意：找图中一个最大的单向连通图

思路：先找双连通分量，然后把图中双连通分量缩成一个点，成为一个有向无环图。找到所有的没有入度的节点，从它们开始DFS，每次记录下所到达节点的符合要求的节点数。

提交的时候有一次忘了初始化，错了一发

代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=1005;

int n,m;

vector<int> G[maxn];
vector<int> GT[maxn];

vector<int> Gscc[maxn];
int weight[maxn];

bool root[maxn];
int dp[maxn];
vector<int> path;
bool in[maxn];
int bcc_cnt=0;
int bccno[maxn];

void dfs1(int u,int fa)
{
    if(in[u])return;
    in[u]=1;
    for(int i=0;i<G[u].size();++i)
    {
        dfs1(G[u][i],u);
    }
    path.push_back(u);
}

void dfs2(int u,int fa)
{
    if(bccno[u])return;
    bccno[u]=bcc_cnt;
    for(int i=0;i<GT[u].size();++i)
    {
        dfs2(GT[u][i],u);
    }
}

void find_scc()
{
    for(int i=1;i<=n;++i)
    {
        dfs1(i,-1);
    }
    for(int i=n-1;i>=0;--i)
    {
        int tmp=path[i];
        if(!bccno[tmp])
        {
            bcc_cnt++;
            dfs2(tmp,-1);
        }
    }
}

void solve(int u,int fa)
{
    int prio=0;
    if(fa!=-1)prio+=dp[fa];
    int w=prio+weight[u];
    if(w<=dp[u])return;
    dp[u]=w;
    for(int i=0;i<Gscc[u].size();++i)
    {
        solve(Gscc[u][i],u);
    }
}

void init()
{
    for(int i=0;i<=n;++i)
    {
        G[i].clear();
        GT[i].clear();
        Gscc[i].clear();
        bccno[i]=0;
        in[i]=0;
        weight[i]=0;
        root[i]=1;
        dp[i]=0;
    }
    path.clear();
    bcc_cnt=0;
}

int main()
{
//    freopen("data.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=0;i<m;++i)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            GT[v].push_back(u);
        }
        find_scc();
        for(int i=1;i<=n;++i)
        {
            weight[bccno[i]]++;
            for(int j=0;j<G[i].size();++j)
            {
                if(bccno[i]!=bccno[G[i][j]])
                {
                       root[bccno[G[i][j]]]=0;
                       Gscc[bccno[i]].push_back(bccno[G[i][j]]);
                }

            }
        }
        for(int i=1;i<=bcc_cnt;++i)
        {
            if(!root[i])continue;
            solve(i,-1);
        }
        int ans=0;
        for(int i=1;i<=bcc_cnt;++i)
        {
            ans=max(dp[i],ans);
        }
        printf("%d\n",ans);
    }
    return 0;
}