UVALive

Problem   UVALive - 5135 - Mining Your Own Business

Time Limit: 5000 mSec

Problem Description

John Digger is the owner of a large illudium phosdex mine. The mine is made up of a series of tunnels that meet at various large junctions. Unlike some owners, Digger actually cares about the welfare of his workers and has a concern about the layout of the mine. Specifically, he worries that there may a junction which, in case of collapse, will cut off workers in one section of the mine from other workers (illudium phosdex, as you know, is highly unstable). To counter this, he wants to install special escape shafts from the junctions to the surface. He could install one escape shaft at each junction, but Digger doesn’t care about his workers that much. Instead, he wants to install the minimum number of escape shafts so that if any of the junctions collapses, all the workers who survive the junction collapse will have a path to the surface. Write a program to calculate the minimum number of escape shafts and the total number of ways in which this minimum number of escape shafts can be installed.

Input

The input consists of several test cases. The first line of each case contains a positive integer N (N ≤ 5·104) indicating the number of mine tunnels. Following this are N lines each containing two distinct integers s and t, where s and t are junction numbers. Junctions are numbered consecutively starting at 1. Each pair of junctions is joined by at most a single tunnel. Each set of mine tunnels forms one connected unit (that is, you can get from any one junction to any other). The last test case is followed by a line containing a single zero.

Output

For each test case, display its case number followed by the minimum number of escape shafts needed for the system of mine tunnels and the total number of ways these escape shafts can be installed. You may assume that the result fits in a signed 64-bit integer. Follow the format of the sample output.

 

Sample Input

9 1 3 4 1 3 5 1 2 2 6 1 5 6 3 1 6 3 2 6 1 2 1 3 2 4 2 5 3 6 3 7 0

Sample Output

Case 1: 2 4

Case 2: 4 1

题解：做这种题就是涨姿势，删掉一个点之后还能连通，对于无向图来说，双连通才能满足这条性质，因此着眼点就放在了双连通分量上。接下来通过点双连通分量缩点来考虑问题。因为一个割点可能属于多个v-BCC，设图中有p个割点和t个v-BCC，我们建立一张包含p+t个节点的新图，把每个v-BCC和每个割点都作为新图中的节点，并在每个割点与包含它的所有v-BCC之间连边。这张图就变成了一棵树或是一片森林。我们可以只考虑树的情况，因为森林中的树相互之间独立，方案数满足乘法原理。随便找个节点转成有根树，则所有叶子节点都是v-BCC（如果叶子节点是割点那把他删去并不会使连通分量数增加），很明显这些节点中都需要一个太平井，之后可以证明除了这些节点需要太平井之外，别的节点都不需要。首先割点节点都是不需要的，因为如果该节点连接的两个双连通分量都只依靠该节点的太平井，那么删去该点之后这两个双连通分量还需要两个太平井，而如果有了这两个太平井，显然割点处的太平井是不需要的，其次，除了叶节点之外的双连通分量节点都至少连接两个割点，因此不论删去哪个割点，该分量节点所在的联通块都至少包含一个叶子节点，因此该节点不需要太平井。之后就是乘法原理了，有个需要注意的地方就是如果整个图是一个BCC，之前的分析就不奏效了，需要重新考虑，不过这种情况很简单，想到了就没问题。

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))

const int maxn = 50000 + 10;
const int maxm = 30 + 10;
const int maxs = 10000 + 10;

typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const LL mod = 1000000007;
const double eps = 1e-14;
const double inf = 1e15;
const double pi = acos(-1.0);

struct Edge
{
    int u, v;
};

int n, m;
vector<int> G[maxn];
int dfs_clock, bcc_cnt;
int pre[maxn], is_cut[maxn], bccno[maxn];
vector<int> bcc[maxn];
stack<Edge> S;

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for (auto v : G[u])
    {
        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])
            {
                is_cut[u] = 1;
                bcc_cnt++;
                bcc[bcc_cnt].clear();
                for (;;)
                {
                    Edge x = S.top();
                    S.pop();
                    if (bccno[x.u] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.u);
                        bccno[x.u] = bcc_cnt;
                    }
                    if (bccno[x.v] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.v);
                        bccno[x.v] = bcc_cnt;
                    }
                    if (x.u == u && x.v == v)
                    {
                        break;
                    }
                }
            }
        }
        else if (pre[v] < pre[u] && v != fa)
        {
            S.push(e);
            lowu = min(lowu, pre[v]);
        }
    }
    if (fa < 0 && child == 1)
    {
        is_cut[u] = 0;
    }
    return lowu;
}

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

int iCase;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    while (cin >> m && m)
    {
        for (int i = 0; i < maxn; i++)
        {
            G[i].clear();
        }
        n = 0;
        int u, v;
        for (int i = 0; i < m; i++)
        {
            cin >> u >> v;
            u--, v--;
            G[u].push_back(v);
            G[v].push_back(u);
            n = max(n, u);
            n = max(n, v);
        }
        find_bcc();
        LL ans1 = 0, ans2 = 1LL;
        for (int i = 1; i <= bcc_cnt; i++)
        {
            int cnt = 0;
            for (auto v : bcc[i])
            {
                if (is_cut[v])
                    cnt++;
            }
            if (cnt == 1)
            {
                ans1++;
                ans2 *= (LL)bcc[i].size() - 1;
            }
        }
        if (bcc_cnt == 1)
        {
            ans1 = 2;
            ans2 *= (LL)bcc[1].size() * (bcc[1].size() - 1) / 2;
        }
        cout << "Case " << ++iCase << ": " << ans1 << " " << ans2 << endl;
    }
    return 0;
}