LA 5135 Mining Your Own Business

　　求出 bcc 后再……根据大白书上的思路即可。

　　然后我用的是自定义的 stack 类模板:

#include<cstdio>
#include<cstring>
#include<vector>
//#include<stack>
#include<stdexcept>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 50003;

template <typename T, size_t SIZE = N>
class stack {
    T *val;
    size_t tot;
    size_t limit;
public:
    stack(size_t limit = SIZE): limit(limit) {
        val = (T*)malloc(sizeof(T) * limit);
        tot = 0;
    }
    stack(const stack<T> &s2): limit(s2.limit), tot(s2.tot) {
        val = (T*)malloc(sizeof(T) * limit);
        for(size_t i = 0; i < tot; ++i)
            val[i] = s2.val[i];
    }
    stack& operator = (const stack<T> &s2) {
        tot = s2.tot;
        limit = s2.limit;
        T *temp = (T*)malloc(sizeof(T) * s2.limit);
        for(size_t i = 0; i < s2.tot; ++i)
            temp[i] = s2.val[i];
        free(val);
        this->val = temp;
    }
    void push(const T &x) {
        if(tot == limit) {
            stack<T> temp(*this);
            free(val);
            val = (T*)malloc(sizeof(T) * (limit <<= 1));
            for(size_t i = 0; i < temp.tot; ++i)
                val[i] = temp.val[i];
        }
        val[tot++] = x;
    }
    void pop() {
        if(tot == 0)    throw out_of_range("Stack less flow at Stack<T>::pop()");
        --tot;
    }
    T top() const {
        if(tot == 0)    throw out_of_range("Stack less flow at Stack<T>::top()");
        return val[tot - 1];
    }
    size_t size() const {   return tot;   }
    bool empty() const {    return tot == 0;    }
    void clear() {   tot = 0;   }
    ~stack() {  free(val);   }
};


struct Edge {
    int u,v;
    Edge(int u, int v): u(u), v(v) {}
};

vector<int> g[N], bcc[N];
int pre[N], iscut[N], bccno[N], dfs_clock, bcc_cnt;
stack<Edge, N> s;

int dfs(int u, int fa) {
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0; i < g[u].size(); ++i) {
        int v = g[u][i];
        Edge e = Edge(u,v);
        if(!pre[v]) {
            s.push(e);
            ++child;
            int lowv = dfs(v,u);
            lowu = min(lowu, lowv);
            if(lowv >= pre[u]) {
                iscut[u] = 1;
                ++bcc_cnt;
                bcc[bcc_cnt].clear();
                while(1) {
                    Edge x = s.top();   s.pop();
                    if(bccno[x.u] != bcc_cnt) {
                        bccno[x.u] = bcc_cnt;
                        bcc[bcc_cnt].push_back(x.u);
                    }
                    if(bccno[x.v] != bcc_cnt) {
                        bccno[x.v] = bcc_cnt;
                        bcc[bcc_cnt].push_back(x.v);
                    }
                    if(x.u == u && x.v == v)    break;
                }
            }
        }
        else if(pre[v] < pre[u] && v != fa) {
            lowu = min(lowu, pre[v]);
            s.push(e);
        }
    }
    if(fa < 0 && child == 1)    iscut[u] = 0;
    return lowu;
}

void find_bcc(int n) {
    memset(pre, 0, sizeof pre);
    memset(iscut, 0, sizeof iscut);
    memset(bccno, 0, sizeof bccno);
    dfs_clock = bcc_cnt = 0;
    for(int i = 0; i < n; ++i)
        if(!pre[i])   dfs(i, -1);
}

int main() {
    int n,x,y,Case = 0, maxn = 1;
    while(~scanf("%d",&n),n) {
        for(int i = 0; i <= maxn; ++i)
            g[i].clear();
        maxn = 1;
        for(int i = 0; i < n; ++i) {
            scanf("%d %d",&x,&y);
            maxn = max(maxn, x);
            maxn = max(maxn, y);
            g[x].push_back(y);
            g[y].push_back(x);
        }
        find_bcc(maxn + 1);
        LL ans1 = 0, ans2 = 1;
        for(int i = 1; i <= bcc_cnt; ++i) {
            int cut = 0;
            for(int j = 0; j < bcc[i].size(); ++j)
                if(iscut[bcc[i][j]])    ++cut;
            if(cut == 1) {
                ++ans1;
                ans2 *= bcc[i].size() - cut;
            }
        }
        if(bcc_cnt == 1) {
            ans1 = 2;
            ans2 = (LL)bcc[1].size() * (bcc[1].size() - 1) / 2;
        }
        printf("Case %d: %lld %lld
",++Case, ans1, ans2);
    }
    return 0;
}