uva 11324 The Largest Clique

Given a directed graph G, con- sider the following transformation.

First, create a new graph T(G) to have the same vertex set as G. Cre-

ate 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 tran- sitive closure of G. We de ne 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. Input

The number of cases is given on the rst 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 de ne a directed edge from u to v in G.

Output For each test case, output a single integer that is the size of

the largest clique in T(G).

很明显，对于每个scc里的点，要不然全选，要不然全不选。于是缩点成dag，以每个scc里包含的点数作为权值，问题变为在dag上找一条点权之和最大的路径。dp即可。

#include<cstdio>
#include<cstring>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define M(a) memset(a,0,sizeof(a))
vector<int> to[1010],scc[1010];
stack<int> sta;
queue<int> que;
int dfn[1010],low[1010],tot,clo,num[1010],dp[1010],du[1010],m,n;
bool ins[1010],ren[1010];
void init()
{
int i;
M(dfn);
M(low);
tot=clo=0;
M(num);
M(dp);
M(du);
M(ins);
for (i=1;i<=1005;i++)
to[i].clear(),scc[i].clear();
while (!sta.empty())
sta.pop();
while (!que.empty())
que.pop();
}
void in()
{
int i,x,y;
scanf("%d%d",&n,&m);
for (i=1;i<=m;i++)
{
scanf("%d%d",&x,&y);
to[x].push_back(y);
}
}
void dfs(int u)
{
int i,j,k,p,q,x,y,z,v;
dfn[u]=low[u]=++clo;
sta.push(u);
ins[u]=1;
for (i=0;i<to[u].size();i++)
{
v=to[u][i];
if (!dfn[v])
{
dfs(v);
low[u]=min(low[u],low[v]);
}
else if (ins[v])
low[u]=min(low[u],dfn[v]);
}
if (low[u]==dfn[u])
{
tot++;
while (1)
{
p=sta.top();
sta.pop();
ins[p]=0;
num[p]=tot;
scc[tot].push_back(p);
if (p==u) break;
}
}
}
void make()
{
for (int i=1;i<=n;i++)
if (!dfn[i]) dfs(i);
}
void solve()
{
int i,j,k,p,q,u,v,x,y,z,ans=0;
for (i=1;i<=tot;i++)
{
M(ren);
for (j=0;j<scc[i].size();j++)
{
u=scc[i][j];
for (k=0;k<to[u].size();k++)
{
v=to[u][k];
if (num[v]!=i&&!ren[num[v]])
{
du[num[v]]++;
ren[num[v]]=1;
}
}
}
}
for (i=1;i<=tot;i++)
if (!du[i]) que.push(i);
while (!que.empty())
{
M(ren);
p=que.front();
que.pop();
dp[p]+=scc[p].size();
ans=max(ans,dp[p]);
for (i=0;i<scc[p].size();i++)
{
u=scc[p][i];
for (j=0;j<to[u].size();j++)
{
v=to[u][j];
if (p!=num[v]&&!ren[num[v]])
{
dp[num[v]]=max(dp[num[v]],dp[p]);
ren[num[v]]=1;
du[num[v]]--;
if (!du[num[v]]) que.push(num[v]);
}
}
}
}
printf("%d\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while (T--)
{
init();
in();
make();
solve();
}
}