UVA11324 The Largest Clique (强联通 + DP)

题目链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=54643#problem/C

 

题意：有一张有向图G 求一个节点数最大的节点集 其中任意2点 u和v 要么u 可以到v 要么v可以到u 要么相互可达

 

思路：先用强联通缩点 每一个强连通分量都是可达的 求一条路径 路径上的每个点的权值即是该强连通分量的节点数 求权最大的路径 可以用记忆化搜索

 

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;

const int maxn = 2020;
const int maxm = 100010;

struct node
{
    int to, nxt;
} e[maxm];

int head[maxn], ecnt, num[maxn];
int low[maxn], dfn[maxn], sta[maxn], top, bel[maxn], block, idx;
bool insta[maxn];
int n, m;

void add(int u, int v)
{
    e[ecnt].to = v;
    e[ecnt].nxt = head[u];
    head[u] = ecnt++;
}

void tarjan(int u)
{
    int v;
    low[u] = dfn[u] = ++idx;
    sta[top++] = u;
    insta[u] = true;
    for(int i = head[u]; ~i; i = e[i].nxt)
    {
        v = e[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else
            if(insta[v] && low[u] > dfn[v])
                low[u] = dfn[v];
    }
    if(low[u] == dfn[u])
    {
        block++;
        do
        {
            v = sta[--top];
            insta[v] = false;
            bel[v] = block;
            num[block]++;
        }
        while(v != u);
    }
}

void solve()
{
    top = block = idx = 0;
    memset(insta, 0, sizeof(insta));
    memset(bel, -1, sizeof(bel));
    memset(dfn, 0, sizeof(dfn));
    memset(num, 0, sizeof(num));
    for (int i = 1; i <= n; i++)
        if (!dfn[i])
            tarjan(i);
}

vector<int> g[maxn];
int dp[maxn], cnt[maxn];

int solve(int u)
{
    if(dp[u] > 0) return dp[u];
    dp[u] = cnt[u];
    for(int i = 0; i < g[u].size(); i++)
    {
        int v = g[u][i];
        dp[u] = max(dp[u], solve(v) + cnt[u]);
    }
    return dp[u];
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int u, v;
        scanf("%d%d", &n, &m);
        memset(head, -1, sizeof(head));
        ecnt = 0;
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &u, &v);
            add(u, v);
        }
        solve();
        for(int i = 0; i <= block; i++)
            g[i].clear();
        memset(cnt, 0, sizeof(cnt));
        for(int i = 1; i <= n; i++)
        {
            u = bel[i];
            cnt[u]++;
            for(int j = head[i]; j != -1; j = e[j].nxt)
            {
                v = bel[e[j].to];
                if(u == v) continue;
                g[u].push_back(v);
            }
        }
        int ans = 0;
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= block; i++)
            ans = max(ans, solve(i));
        printf("%d\n", ans);
    }
}