uva 11324

Problem B: The Largest Clique

Given a directed graph G, consider the following transformation. First, create a new graph T(G) to have the same vertex set as G. Create a directed edge between two vertices u and v in T(G) if and only if there is a path between u and v in G that follows the directed edges only in the forward direction. This graph T(G) is often called the transitive closure of G.

We define a clique in a directed graph as a set of vertices U such that for any two vertices u and v in U, there is a directed edge either from u to v or from v to u (or both). The size of a clique is the number of vertices in the clique.

The number of cases is given on the first line of input. Each test case describes a graph G. It begins with a line of two integers n and m, where 0 ≤ n ≤ 1000 is the number of vertices of G and 0 ≤ m ≤ 50,000 is the number of directed edges of G. The vertices of G are numbered from 1 to n. The following m lines contain two distinct integers u and v between 1 and n which define a directed edge from u to v in G.

For each test case, output a single integer that is the size of the largest clique in T(G).

Sample input

1
5 5
1 2
2 3
3 1
4 1
5 2

Output for sample input

4

---

Zachary Friggstad

强连通分量缩点成DAG,求点集最大的路径。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <stack>
 #include <vector>

 using namespace std;

 const int MAX_N = ;
 const int edge = 5e4 + ;
 int N,M;
 int low[MAX_N],pre[MAX_N],cmp[MAX_N];
 int first[MAX_N],Next[edge],v[edge];
 int ind[MAX_N],oud[MAX_N];
 int dfs_clock,scc_cnt;
 int dep[MAX_N];
 int num[MAX_N];
 stack <int > S;
 vector<int > G[MAX_N];

 void dfs(int u) {
         pre[u] = low[u] = ++dfs_clock;
         S.push(u);
         for(int e = first[u]; e != -; e = Next[e]) {
                 if(!pre[ v[e] ]) {
                         dfs(v[e]);
                         low[u] = min(low[u],low[ v[e] ]);
                 } else if( !cmp[ v[e] ]) {
                         low[u] = min(low[u],pre[ v[e] ]);
                 }
         }

         if(pre[u] == low[u]) {
                 ++scc_cnt;
                 for(;;) {
                         int x = S.top(); S.pop();
                         cmp[x] = scc_cnt;
                         num[scc_cnt]++;
                         if(x == u) break;
                 }
         }
 }
 void scc() {
         dfs_clock = scc_cnt = ;
         memset(cmp,,sizeof(cmp));
         memset(pre,,sizeof(pre));

         for(int i = ; i <= N; ++i) if(!pre[i]) dfs(i);
 }

 void dfs1(int u) {
         pre[u] = ;
         for(int i = ; i < G[u].size(); ++i) {
                 if(!pre[ G[u][i] ]) {
                         dfs1( G[u][i] );
                 }
                 dep[u] = max(dep[u],dep[ G[u][i] ] + num[u]);
         }
 }

 void solve() {
         scc();
         for(int i = ; i <= scc_cnt; ++i) G[i].clear();
         for(int i = ; i <= scc_cnt; ++i) dep[i] = num[i];

         for(int i = ; i <= N; ++i) {
                 for(int e = first[i]; e != -; e = Next[e]) {
                         if(cmp[i] == cmp[ v[e] ]) continue;
                         G[ cmp[i] ].push_back(cmp[ v[e] ]);
                 }
         }

         memset(pre,,sizeof(pre));
         for(int i = ; i <= scc_cnt; ++i) {
                 if(!pre[i]) dfs1(i);
         }

         int ans = ;
         for(int i = ; i <= scc_cnt; ++i) {
                 ans = max(ans,dep[i]);
         }

         printf("%d\n",ans);

 }

 void add_edge(int id,int u) {
         int e = first[u];
         Next[id] = e;
         first[u] = id;
 }
 int main()
 {
     //freopen("sw.in","r",stdin);
     int t;
     scanf("%d",&t);
     while(t--) {
             scanf("%d%d",&N,&M);
             for(int i = ; i <= N; ++i) first[i] = -;
             memset(num,,sizeof(num));

             for(int i = ; i <= M; ++i) {
                     int u;
                     scanf("%d%d",&u,&v[i]);
                     add_edge(i,u);
             }

             solve();
     }
     //cout << "Hello world!" << endl;
     return ;
 }