Uva Mining Your Own Business（点双连通分量）

题目地址：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3549

思路：

1.蓝书描述：在一个无向图上选择尽量少的点涂黑（对应太平井），使得任意删除一个点后，每个连通分量至少有一个黑点。

2.涂黑割点是不划算的：若删除割点，图不连通，对于剩余连通分量若保证各至少有一个黑点，则仍需至少两点（两连通分量各一个）。若不涂黑割点，删除后两连通分量中一连通分量中已有黑点，只需另一连通分量中有一黑点即可。所以不能选择割点。

3.对于一点双连通分量，任意两点至少存在两条点不重复的路径，则一点连通分量中若涂黑，则只需涂黑一个：（1）若一点连通分量有且仅有一个割点，则需涂黑连通分量中任意一个非割点（若删除割点，保证该连通分量中至少存在一黑点）。（2）若有多于两个割点，则无需涂黑：若删除一割点，剩余点可通过另一割点到达其他连通分量黑点（两连通分量通过割点相连）。

4.对于无割点图：只需任取两点涂黑即可。

#include<stack>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#define debug
using namespace std;
const int maxn=5e4+50;
typedef long long LL;
struct Edge
{
    int u,v;
};

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

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]=true;
                cut_num++;
                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)
    {
        iscut[u]=0;
        cut_num--;
    }
    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()
{
#ifdef debu
    freopen("in.txt","r",stdin);
#endif // debug
    int cas=0;
    while(scanf("%d",&m)!=EOF&&m)
    {
        n=0;cut_num=0;
        for(int i=0; i<=m; i++) G[i].clear();
        for(int i=0; i<m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            n=max(n,max(u,v));
            u--,v--;
            G[u].push_back(v);
            G[v].push_back(u);
        }
        find_bcc(n);
        if(cut_num==0)
        {
          printf("Case %d: %d %d\n",++cas,2,(LL)n*(n-1)/2);
        }
        else
        {
          LL ans=1;
          int ans_num=0;
          for(int i=1;i<=bcc_cnt;i++)
          {
            int num=0;
            for(int j=0;j<bcc[i].size();j++)
            {
              if(iscut[bcc[i][j]]) num++;
              if(num>1) break;
            }
            if(num==1)
            {
               ans*=bcc[i].size()-1;
               ans_num+=1;
            }
          }
          printf("Case %d: %d %lld\n",++cas,ans_num,ans);
        }
    }
    return 0;
}