UVA11324 The Largest Clique (强连通缩点+DP最长路)

<题目链接>

题目大意：

给你一张有向图 G，求一个结点数最大的结点集，使得该结点集中的任意两个结点 u 和 v 满足：要么 u 可以达 v，要么 v 可以达 u（u,v相互可达也行）。

解题分析：

该点集需满足两个要求：1.任意两点至少有一方能够到达另外一点;2.点数尽可能的多。

通过画图分析可以知道，对于那些强连通分量来说，要不就全部加入该点集，要不就全部不能加入，所以直接对原图进行缩点，进行重新构图。然后，根据重新构造的DAG图我们可以知道，要使该点集中任意两点至少有一方能够到达另外一点，并且要求点数尽可能的多，可以发现，其实就是让我们求缩点后的最长路。

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <algorithm>
 using namespace std;

 #define pb push_back
 #define clr(a,b) memset(a,b,sizeof(a))
 #define rep(i,s,t) for(int i=s;i<=t;i++)
 const int N = 1e3+,M = 5e4+;
 int n,m,tot,tott,top,scc;
 int head[N],belong[N],dfn[N],low[N],stk[N],instk[N],dp[N],cnt[N];
 vector<int>G[N];
 struct Edge{
     int to,next;
 }edge[M];
 void init(){
     rep(i,,n)G[i].clear();
     tot=scc=top=tott=;
     clr(head,-);clr(low,);clr(dfn,);clr(stk,);clr(instk,);clr(belong,);clr(dp,);clr(cnt,);
 }
 void addedge(int u,int v){
     edge[++tot].to=v,edge[tot].next=head[u];
     head[u]=tot;
 }
 void Tarjan(int u){       //进行缩点
     dfn[u]=low[u]=++tott;
     stk[++top]=u;instk[u]=;
     for(int i=head[u];~i;i=edge[i].next){
         int v=edge[i].to;
         if(!dfn[v]){
             Tarjan(v);
             low[u]=min(low[u],low[v]);
         }else if(instk[v])low[u]=min(low[u],dfn[v]);
     }
     if(dfn[u]==low[u]){
         scc++;
         while(true){
             int v=stk[top--];
             instk[v]=;
             belong[v]=scc;
             cnt[scc]++;
             if(v==u)break;
         }
     }
 }
 //记忆化搜索求以u为起点的最长路，点权为"点"中点的个数
 int DFS(int u){
     if(dp[u])return dp[u];
     int ans=cnt[u];
     for(int i=;i<G[u].size();i++){
         int v=G[u][i];
         ans=max(ans,DFS(v)+cnt[u]);
     }
     return dp[u]=ans;
 }
 int main(){
     int T;scanf("%d",&T);while(T--){
         init();
         scanf("%d%d",&n,&m);
         rep(i,,m){
             int u,v;scanf("%d%d",&u,&v);
             addedge(u,v);
         }
         rep(i,,n)
             if(!dfn[i])Tarjan(i);
         //对图进行缩点，重新构图
         rep(u,,n) for(int i=head[u];~i;i=edge[i].next){
             int v=edge[i].to;
             if(belong[u]!=belong[v])
                 G[belong[u]].pb(belong[v]);
         }
         int ans=;
         rep(i,,scc)
             ans=max(ans,DFS(i));   //求缩点后图的最长路
         printf("%d\n",ans);
     }
 }

2018-11-28