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 = 1005;
const int edge = 5e4 + 5;
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 != -1; 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 = 0;
        memset(cmp,0,sizeof(cmp));
        memset(pre,0,sizeof(pre));

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

void dfs1(int u) {
        pre[u] = 1;
        for(int i = 0; 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 = 1; i <= scc_cnt; ++i) G[i].clear();
        for(int i = 1; i <= scc_cnt; ++i) dep[i] = num[i];

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

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

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

        printf("%d
",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 = 1; i <= N; ++i) first[i] = -1;
            memset(num,0,sizeof(num));

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

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