UVALive 5135 Mining Your Own Business 双连通分量

据说这是一道Word Final的题，Orz。。。

原题链接：https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3136

题意：

给你一个联通图，让你选择一些点，使得这个图的任意一个点消失后，其余的点都能到达某个你选择的点。问你最少选择哪些点，并且输出在最优的情况下，有多少方案。

题解：

一眼看过去，做法很简单，就删掉所有的割点后，考察联通块的个数就好。但这道题满满的坑。。要不怎么是总决赛的题。。

首先如果这个图只有一个联通块，那么答案就应该是任选两个点，这是因为，如果其中一个点挂了，还能走另外一个点。

如果一个联通块有大于一个割点，那么这个联通块就不需要，这是因为两个割点不可能同时挂了。

代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#define MAX_V 50004
using namespace std;

int V=;
vector<int> G[MAX_V];
int N;

int dfn[MAX_V],low[MAX_V],ind=;
bool vis[MAX_V];
bool isCut[MAX_V];
int tot=;

long long ways=;
long long tmp=;
long long cnt=;

bool used[MAX_V];
set<int> se;

void init(){
    se.clear();
    V=ind=cnt=tmp=;
    ways=;
    memset(used,,sizeof(used));
    memset(dfn,,sizeof(dfn));
    memset(low,,sizeof(low));
    memset(vis,,sizeof(vis));
    memset(isCut,,sizeof(isCut));
    for(int i=;i<=N+;i++)G[i].clear();
}

void Tarjan(int u,int p) {
    dfn[u] = low[u] = ++ind;
    vis[u]=;
    int child = ;
    for (int i = ; i < G[u].size(); i++) {
        int v = G[u][i];
        if (v == p)continue;
        if (!vis[v]) {
            child++;
            Tarjan(v, u);
            low[u] = min(low[v], low[u]);
            if (p ==  && child > )isCut[u] = ;
            if (p&&low[v] >= dfn[u])
                isCut[u] = ;
            tot+=isCut[u];
        }
        else
            low[u] = min(dfn[v], low[u]);
    }
}

void dfs(int u) {
    if (used[u] || isCut[u])return;
    tmp++;
    used[u] = ;
    for (int i = ; i < G[u].size(); i++){
        int v=G[u][i];
        if(isCut[v]){
            se.insert(v);
            continue;
        }
        dfs(v);
    }
}

int main() {
    int cas = ;
    cin.sync_with_stdio(false);
    while (cin >> N) {
        tot=;
        if (N == )break;
        init();
        for (int i = ; i < N; i++) {
            int u, v;
            cin >> u >> v;
            V = max(V, max(u, v));
            G[u].push_back(v);
            G[v].push_back(u);
        }
        Tarjan(, );
        cout << "Case " << ++cas << ": ";
        if (tot == ) {
            cout <<  << " " << (long long)V * (V - ) /  << endl;
            continue;
        }
        for (int u = ; u <= V; u++) {
            if (isCut[u])continue;
            tmp = ;
            if (!used[u]) {
                se.clear();
                dfs(u);
                if (se.size() ==  && tmp) {
                    ways *= tmp;
                    cnt++;
                }
            }
        }
        cout << cnt << " " << ways << endl;
    }
    return ;
}