uva 11324 - The Largest Clique（缩点 + dp）

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

1
5 5
1 2
2 3
3 1
4 1
5 2

Output for sample input

4

---

Zachary Friggstad

先把强连通分量缩点后得到scc图，每个scc节点的权等于他的节点数，因为scc是dag图，所以可以用dp求解。

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

const int maxn = 1000 + 5;

vector<int> G[maxn];
int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u) {
  pre[u] = lowlink[u] = ++dfs_clock;
  S.push(u);
  for(int i = 0; i < G[u].size(); i++) {
    int v = G[u][i];
    if(!pre[v]) {
      dfs(v);
      lowlink[u] = min(lowlink[u], lowlink[v]);
    } else if(!sccno[v]) {
      lowlink[u] = min(lowlink[u], pre[v]);
    }
  }
  if(lowlink[u] == pre[u]) {
    scc_cnt++;
    for(;;) {
      int x = S.top(); S.pop();
      sccno[x] = scc_cnt;
      if(x == u) break;
    }
  }
}

void find_scc(int n) {
  dfs_clock = scc_cnt = 0;
  memset(sccno, 0, sizeof(sccno));
  memset(pre, 0, sizeof(pre));
  for(int i = 0; i < n; i++)
    if(!pre[i]) dfs(i);
}

vector<int> Map[maxn];
int val[maxn];
int dp[maxn];

int find(int x){
    if(Map[x].size() == 0) return dp[x] = val[x];
    if(dp[x]) return dp[x];
    int Max = 0;
    for(int i = 0;i < Map[x].size();i++)
        Max = max(Max,find(Map[x][i]));
    return dp[x] = val[x] + Max;
}

int main(){
    int t,n,m;
    scanf("%d",&t);
    while(t--){
        memset(val,0,sizeof(val));
        for(int i = 0;i < maxn;i++) { G[i].clear(); Map[i].clear(); }
        memset(dp,0,sizeof(dp));
        scanf("%d%d",&n,&m);
        while(m--){
            int u,v;
            scanf("%d%d",&u,&v);u--;v--;
            if(u == v) continue;
            G[u].push_back(v);
        }

        find_scc(n);

        for(int u = 0;u < n;u++){
            val[sccno[u]]++;
            for(int j = 0;j < G[u].size();j++){
                int v = G[u][j];
                    if(sccno[u] != sccno[v])
                        Map[sccno[u]].push_back(sccno[v]);
            }
        }
        
        int ans = 0;
        for(int i = 0;i <= scc_cnt;i++)
            ans = max(ans,find(i));
        printf("%d\n",ans);
    }
    return 0;
}