UVA 1324 The Largest Clique 最大团(强连通分量，变形)

题意：给一个有向图，要求找出一些点，使得这些点中的任意点对，要么可以互通，要么单向可达。

思路：最低只要求单向可达即可，即a->b都可以算进去。

　　强连通分量内的点肯定是满足要求的，可以全选，但是有多个强连通分量时就不行了，得有取舍。老方法，先缩点，缩完点后是没有环的存在的，所以就是拓扑图了。如果只给一个拓扑图，要求找一条链使得链上的点最多，那么可以用判断拓扑的方式，逐个将入度为0的点删除，且在删除的时候记录下最多有多少个点，删到最后一个点时就出结果了。这样的方法同样适用，只是每个点可能是缩点，而且要将这些缩点内的点数算上去而已。

实现：

　　（1）求强连通分量。

　　（2）统计缩点的度数并建（缩点）图。

　　（3）按判断拓扑图的方式来进行点数的统计。

 #include <bits/stdc++.h>
 #define LL long long
 #define pii pair<int,int>
 using namespace std;
 const int N=+;
 const int INF=0x7f7f7f7f;
 vector<int> vect[N], g[N];  //原图，缩点后的图
 int n, m;
 int dfn[N], lowlink[N], scc_no[N], dfn_clock, scc_cnt; //强连通分量必备
 stack<int> stac;    //强联通分量用栈
 unordered_map<int,int> chu[N],ru[N];    //仅仅为了防止重复统计
 int  r[N]; //出入度
 int num[N];     //强联通分量中的点数
 int dp[N];      //答案

 void DFS(int x)
 {
     stac.push(x);
     dfn[x]=lowlink[x]=++dfn_clock;
     for(int i=; i<vect[x].size(); i++)
     {
         int t=vect[x][i];
         if(!dfn[t])
         {
             DFS(t);
             lowlink[x]=min(lowlink[x],lowlink[t]);
         }
         else if(!scc_no[t])    lowlink[x]=min(lowlink[x], dfn[t]);
     }
     if(lowlink[x]==dfn[x])
     {
         ++scc_cnt;
         while(true)
         {
             int t=stac.top();stac.pop();
             scc_no[t]=scc_cnt;
             if(t==x)    break;
         }
     }
 }

 int cal()
 {
     memset(dfn,,sizeof(dfn));
     memset(lowlink,,sizeof(lowlink));
     memset(scc_no,,sizeof(scc_no));
     dfn_clock=scc_cnt=;
     for(int i=; i<=n; i++) if(!dfn[i]) DFS(i);

     if(scc_cnt==)  return n;
     for(int i=; i<=scc_cnt; i++)   g[i].clear(),chu[i].clear(),ru[i].clear();
     for(int i=; i<=n; i++) //统计度，建图
     {
         for(int j=; j<vect[i].size(); j++)
         {
             int t=vect[i][j];
             if(scc_no[i]!=scc_no[t])
             {
                 if(!chu[scc_no[i]][scc_no[t]])   //还没出现过
                 {
                     chu[scc_no[i]][scc_no[t]]=;
                     g[scc_no[i]].push_back(scc_no[t]);
                 }
                 ru[scc_no[t]][scc_no[i]]=;
             }
         }
     }
     deque<int> que;
     memset(r,,sizeof(r));
     for(int i=; i<=scc_cnt; i++)   //统计出入度
     {
         r[i]=ru[i].size();
         if(!r[i])   que.push_back(i);
     }

     memset(num,,sizeof(num));
     for(int i=; i<=n; i++)    num[scc_no[i]]++;    //统计点数

     memset(dp,,sizeof(dp));    //按拓扑序来dp
     int ans=;
     while(!que.empty())
     {
         int siz=que.size();
         for(int i=; i<siz; i++)    //所有入度为0的节点
         {
             int t=que.front();que.pop_front();
             ans=max(ans,dp[t]+num[t]);
             for(int j=; j<g[t].size(); j++)    //每条以t出发的边
             {
                 int d=g[t][j];
                 r[d]--;
                 if(!r[d])  que.push_back(d);
                 dp[d]=max(dp[d],dp[t]+num[t]);
             }
         }
     }
     return ans;
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);

     int t, a, b;
     cin>>t;
     while(t--)
     {
         scanf("%d%d", &n, &m);
         for(int i=; i<=n; i++) vect[i].clear();
         for(int i=; i<m; i++)
         {
             scanf("%d%d",&a,&b);
             vect[a].push_back(b);
         }
         cout<<cal()<<endl;
     }
     return ;
 }

AC代码