[UVA 11324]The Largest Clique[SCC][缩点]

题目链接： [UVA 11324]The Largest Clique[SCC][缩点]

题意分析：

找到最多的节点集合，使得集合内任意两个点之间都有一条路径使得u->v或者v->u。输出该集合的结点个数。

解题思路：

有向图中，强连通分量中的点肯定是互相可达的，所以选择了其中的一个点，必定连通分量中其它的点也要选择，所以我们可以把这些点看作同一个点进行缩点。

那么原问题就变成，从图中找一条路，使得路上的结点权值（新点所包含的点的个数）之和最大。由于新图是DAG（Directed Acyclic Graph。有向无回路图）这里用dp[]记录从该点到其叶子结点最大的权值和，num[i]记录新图中结点的权值。

缩点可以使用两次dfs来进行（参考《挑战程序设计》），或者使用tarjan。这里采用前者。

个人感受：

有向图怎么缩点啊啊啊啊啊。。。。凭借着顽强的意淫能力，意淫了好久。。。还参考了最小树形图的缩点。。。。结果还是GG。正在我死循环时，队友告诉我，SCC啊= =。我去= =。然后今晚查的时候发现，原来tarjan也行= =，只要把上次的无向图中的缩点改改就行了，果然还是理解不到位啊= =。

具体代码如下：

#include<algorithm>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<string>
#define ll long long
#define pr(x) cout << #x << " = " << (x) << '\n';
using namespace std;

const int INF = 0x7f7f7f7f;
const int MAXN = 1e3 + 111;
const int MAXM = 5e4 + 111;

int n, m;
vector<int> G[MAXN], rG[MAXN], nG[MAXN];
vector<int> vs;
bool used[MAXN];
int block;

int belong[MAXN], num[MAXN], dp[MAXN];
int a[MAXM], b[MAXM];

void init() {
    block = 0;
    for (int i = 0; i <= n; ++i) {
        num[i] = dp[i] = 0;
        G[i].clear();
        rG[i].clear();
        nG[i].clear();
    }
}

void dfs(int v) {
    used[v] = 1;
    for (int i = 0; i < G[v].size(); ++i) {
        if (!used[G[v][i]]) dfs(G[v][i]);
    }
    vs.push_back(v);
}

void rdfs(int v, int k) {
    used[v] = 1;
    belong[v] = k;
    ++num[k];
    for (int i = 0; i < rG[v].size(); ++i) {
        if (!used[rG[v][i]]) rdfs(rG[v][i], k);
    }
}

int scc() {
    vs.clear();
    memset(used, 0, sizeof used);
    for (int v = 1; v <= n; ++v) {
        if (!used[v]) dfs(v);
    }
    memset(used, 0, sizeof used);
    int k = 0;
    for (int i = vs.size() - 1; i >= 0; --i) {
        if (!used[vs[i]]) rdfs(vs[i], ++k);
    }
    return k;
}

int dfsans(int x) {
    if (nG[x].size() == 0) dp[x] = num[x];
    if (dp[x]) return dp[x];

    int mx = 0;
    for (int i = 0; i < nG[x].size(); ++i) {
        mx = max(mx, dfsans(nG[x][i]));
    }
    return dp[x] = num[x] + mx;
}

int main()
{
    int kase, u, v; scanf("%d", &kase);
    while (kase --) {
        scanf("%d%d", &n, &m);
        init();
        for (int i = 0; i < m; ++i) {
            scanf("%d%d", &u, &v);
            a[i] = u, b[i] = v;
            G[u].push_back(v);
            rG[v].push_back(u);
        }

        block = scc();
        for (int i = 0; i < m; ++i) {
            if (belong[a[i]] == belong[b[i]]) continue;
            nG[belong[a[i]]].push_back(belong[b[i]]);
            //cout << a[i] << "->" << b[i] << endl;
            //cout << belong[a[i]] << "->" << belong[b[i]] << endl;
        }

        int ans = 0;
        for (int i = 1; i <= block; ++i) {
            ans = max(ans, dfsans(i));
        }

        printf("%d\n", ans);
    }
    return 0;
}