图论trainning-part-2 C. The Largest Clique

C. The Largest Clique

Time Limit: 3000ms

Memory Limit: 131072KB

64-bit integer IO format: %lld Java class name: Main

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 nand 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 ofG 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

Output for sample input

4

解题：强连通子图的求解，缩点，DAG上的动态规划。先求出所有的强连通子图后，再对各个强连通子图进行缩点，所谓缩点，即为把这个强连通块作为一个点，进行新图的建立。原来图上的任意一点必然属于某个强连通块。所以根据各点所在的连通块，进行新图的建立，注意方向性，DAG上的动态规划是对于有向图而言的，所以必须保证方向的正确性。建立新图后，求DAG上的最长路径即可。

 #include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <algorithm>

 #include <climits>

 #include <vector>

 #include <queue>

 #include <cstdlib>

 #include <string>

 #include <set>

 #include <stack>

 #define LL long long

 #define INF 0x3f3f3f3f

 using namespace std;

 const int maxn = ;

 int low[maxn],dfn[maxn],iindex,sccBlocks;

 bool instack[maxn],vis[maxn];

 int belong[maxn],val[maxn],dp[maxn],n,m;

 stack<int>s;

 vector<int>g[maxn];

 vector<int>mp[maxn];

 void tarjan(int u){

     dfn[u] = low[u] = ++iindex;

     instack[u] = true;

     s.push(u);

     for(int i = ; i < g[u].size(); i++){

         int v = g[u][i];

         if(!dfn[v]){

             tarjan(v);

             low[u] = min(low[u],low[v]);

         }else if(instack[v] && low[u] > dfn[v]) low[u] = dfn[v];

     }

     if(dfn[u] == low[u]){

         int v;

         sccBlocks++;

         do{

             v = s.top();

             s.pop();

             instack[v] = false;

             belong[v] = sccBlocks;

         }while(u != v);

     }

 }

 int dag(int u){

     if(dp[u]) return dp[u];

     else if(mp[u].size() == ) return dp[u] = val[u];

     int ans = ;

     for(int v = ; v < mp[u].size(); v++){

         ans = max(ans,dag(mp[u][v]));

     }

     return dp[u] = ans+val[u];

 }

 int main(){

     int t,u,v,i,j;

     scanf("%d",&t);

     while(t--){

         scanf("%d%d",&n,&m);

         for(i = ; i <= n; i++){

             g[i].clear();

             dfn[i] = low[i] = ;

             instack[i] = false;

             val[i] = belong[i] = ;

             dp[i] = ;

             mp[i].clear();

         }

         for(i = ; i < m; i++){

             scanf("%d%d",&u,&v);

             g[u].push_back(v);

         }

         iindex = sccBlocks = ;

         for(i = ; i <= n; i++)

             if(!dfn[i]) tarjan(i);

         for(u = ; u <= n; u++){

             val[belong[u]]++;

             memset(vis,false,sizeof(vis));

             for(j = ; j < g[u].size(); j++){

                 v = g[u][j];

                 if(!vis[belong[v]] && belong[v] != belong[u]){

                     vis[belong[v]] = true;

                     mp[belong[u]].push_back(belong[v]);

                 }

             }

         }

         int ans = ;

         for(i = ; i <= sccBlocks; i++)

             ans = max(ans,dag(i));

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

     }

     return ;

 }