UVA 11324 The Largest Clique (强连通分量缩点，图DP)

题目：

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=25&page=show_problem&problem=2299

题意：

给你一个有向图，求一个点集合的最大大小，使得此点集合中对于任意点对(u,v)，有从u到v或者从v到u的边

方法：

先找强连通分量缩点，每个强连通分量显然满足条件，然后在缩点后的图中找到一条权值最大的路径，权值为此路径的点权之和，点权为这个强连通分量的点数

int dp[maxn];
int dfs(int u)
{
    if (dp[u]) return dp[u];
    int ret = 0;
    for (int i = head[u]; ~i; i = edge[i].next)
        ret = max(ret, dfs(edge[i].v));
    return dp[u] = ret + node[u];
}

代码：

/********************************************
*ACM Solutions
*
*@Title:
*@Version: 1.0
*@Time: 2014-xx-xx
*@Solution: http://www.cnblogs.com/xysmlx/p/xxxxxxx.html
*
*@Author: xysmlx(Lingxiao Ma)
*@Blog: http://www.cnblogs.com/xysmlx
*@EMail: xysmlx@163.com
*
*Copyright (C) 2011-2015 xysmlx(Lingxiao Ma)
********************************************/
// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <ctime>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
#define pb push_back
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn = 1010;
const int maxm = 200010;
const int inf = 0x3f3f3f3f;
const ll inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
int kase;
int n, m;
struct Edge
{
    int u, v;
    int next;
    Edge(int _u, int _v, int _next): u(_u), v(_v), next(_next) {}
    Edge() {}
} edge[maxm];
int en;
int head[maxn];
int node[maxn];
void addse(int u, int v)
{
    edge[en] = Edge(u, v, head[u]);
    head[u] = en++;
}
struct SCC
{
    Edge edge[maxm];
    int en;
    int head[maxn];
    int h[maxn];
    void addse(int u, int v)
    {
        edge[en] = Edge(u, v, head[u]);
        head[u] = en++;
    }
    void init()
    {
        memset(head, -1, sizeof(head));
        en = 0;
    }
    int sid[maxn];
    int mark[maxn], low[maxn];
    int check[maxn];
    int sstack[maxn], top;
    int dfn, ssn;
    int n, m;
    bool mtx[maxn][maxn];
    void dfs(int k)
    {
        int i, j;
        check[k] = 1;
        low[k] = mark[k] = dfn++;
        sstack[top++] = k;
        for (int i = head[k]; i != -1; i = edge[i].next)
        {
            int j = edge[i].v;
            if (mark[j] == 0)
            {
                dfs(j);
                low[k] = min(low[k], low[j]);
            }
            else if (check[j])
                low[k] = min(low[k], mark[j]);
        }
        if (mark[k] == low[k])
        {
            while (sstack[--top] != k)
            {
                check[sstack[top]] = 0;
                sid[sstack[top]] = ssn;
            }
            sid[k] = ssn;
            check[k] = 0;
            ++ssn;
        }
        return;
    }
    void tarjan()
    {
        ssn = 1;
        dfn = 1;
        top = 0;
        memset(check, 0, sizeof(check));
        memset(mark, 0, sizeof(mark));
        for (int i = 0; i < n; ++i) if (mark[i] == 0) dfs(i);

        memset(h, 0, sizeof(h));
        for (int i = 0; i < n; i++)
            h[sid[i]]++;
        memset(mtx, 0, sizeof(mtx));
        for (int i = 0; i < en; i++)
            mtx[sid[edge[i].u]][sid[edge[i].v]] = 1;
    }
} scc;

int dp[maxn];
int dfs(int u)
{
    if (dp[u]) return dp[u];
    int ret = 0;
    for (int i = head[u]; ~i; i = edge[i].next)
        ret = max(ret, dfs(edge[i].v));
    return dp[u] = ret + node[u];
}

void init()
{
    kase++;
    scc.init();
    memset(head, -1, sizeof(head));
    en = 0;
    memset(dp, 0, sizeof(dp));
}
void input()
{
    scanf("%d%d", &n, &m);
    scc.n = n;
    for (int i = 0; i < m; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        u--, v--;
        scc.addse(u, v);
    }
}
void debug()
{
    //
}
void solve()
{
    scc.tarjan();
    n = scc.ssn;
    for (int i = 1; i < scc.ssn; i++)
    {
        for (int j = 1; j < scc.ssn; j++)
        {
            if (i == j) continue;
            if (scc.mtx[i][j])
                addse(i, j);
        }
    }
    for (int i = 1; i < scc.ssn; i++)
        node[i] = scc.h[i];
    // for (int i = 1; i < scc.ssn; i++)
    //     cout << node[i] << " ";
    // cout << endl;
    int ans = 0;
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i < n; i++)
    {
        ans = max(ans, dfs(i));
    }
    printf("%d
", ans);
}
void output()
{
    //
}
int main()
{
    // 32-bit
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movl %0, %%esp
" :: "r"(p));

    // 64-bit
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movq %0, %%rsp
" :: "r"(p));

    // std::ios_base::sync_with_stdio(false);
#ifdef xysmlx
    freopen("in.txt", "r", stdin);
#endif

    kase = 0;
    int T;
    scanf("%d", &T);
    while (T--)
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}