UVA 11324 Problem B: The Largest Clique(强连通+DP，4级)

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 tov 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

思路：强连通缩点后，个缩后的点一个权值，就是当前点包含点的个数，然后搜条权值最大的路径就是个水DP了。

159MS

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int mm=1000+9;
const int mn=5e4+9;
int head[mm],edge;
class node
{
  public:int v,next;
}e[mn],cun[mn];
int m,n;
void add(int u,int v)
{
  e[edge].v=v;e[edge].next=head[u];head[u]=edge++;
}
void data()
{
  memset(head,-1,sizeof(head));edge=0;
}
int bcc_no,dfs_clock,e_to[mm],dfn[mm];
int stak[mm],top,cost[mm];
int tarjan(int u)
{ stak[++top]=u;
  int lowv,lowu,v;
  dfn[u]=lowu=++dfs_clock;
  for(int i=head[u];~i;i=e[i].next)
  {v=e[i].v;
    if(!dfn[v])
    {
      lowv=tarjan(v);
      lowu=min(lowu,lowv);
    }
    else if(!e_to[v])
      lowu=min(dfn[v],lowu);
  }
  if(dfn[u]==lowu)
  {
    bcc_no++;int num=0;
    while(1)
    { ++num;
      v=stak[top--];e_to[v]=bcc_no;
      if(v==u)break;
    }
    cost[bcc_no]=num;
  }
  return lowu;
}
void find_gcc()
{
  memset(dfn,0,sizeof(dfn));
  memset(e_to,0,sizeof(e_to));
  bcc_no=top=dfs_clock=0;
  for(int i=1;i<=n;++i)
    if(!dfn[i])tarjan(i);
}
int dp[mm];
int dfs(int u)
{ int v;
  if(dp[u])return dp[u];
  for(int i=head[u];~i;i=e[i].next)
  {
    v=e[i].v;
    dp[u]=max(dp[u],dfs(v));
  }
  dp[u]+=cost[u];
  return dp[u];
}
int solve()
{
  data();int u,v;
  for(int i=0;i<m;++i)
  {
    u=e_to[cun[i].next];v=e_to[cun[i].v];
    if(u^v)
    {
      add(u,v);
    }
  }
  int ans=0;
  memset(dp,0,sizeof(dp));
  for(int i=1;i<=bcc_no;++i)
    {ans=max(ans,dfs(i));
     ///cout<<i<<" "<<dp[i]<<endl;
    }
    return ans;
}
int main()
{
  int cas,a,b;
  while(~scanf("%d",&cas))
  {
    while(cas--)
    { data();
      scanf("%d%d",&n,&m);
      for(int i=0;i<m;++i)
      {
        scanf("%d%d",&a,&b);
        cun[i].next=a;cun[i].v=b;
        if(a==b)continue;
        add(a,b);
      }
      find_gcc();
      int ans=solve();
      if(n==0)ans=0;
      printf("%d\n",ans);
    }
  }
  return 0;
}