HDU 3844 Mining Your Own Business（割点，经典）

题意：

　　给出一个连通图，要求将某些点涂黑，使得无论哪个点（包括相关的边）撤掉后能够成功使得剩下的所有点能够到达任意一个涂黑的点，颜料不多，涂黑的点越少越好，并输出要涂几个点和有多少种涂法。

思路：

　　要使得任意撤掉一个点都能使其他点能够到达黑点，那么点双连通分量能保证这点，那么就在同个点双连通分量内涂黑1个点。但是每个【点双连通分量】都涂吗？太浪费颜料了，那就缩点成树，只需要涂叶子即可，那就找度为1的缩点。但是种数呢？叶子内的点除了割点外都是可以涂黑的，因为如果黑色割点被撤掉，那么叶子中的其他点怎么办?所以不能涂割点，每个黑点有【叶子中的点数-1】种涂法，所有黑店的涂法相乘为第2个结果。

　　特殊情况，因为给的是连通图且至少有2个点，那么还可能会出现没有割点的情况（仅1个点双连通分量），那就直接涂黑两个，以防一个黑点被撤掉。

　　此题出现的连续的点可能多达10万个，DFS就会爆栈。在C++下可以手动开栈，G++下的还不清楚怎么开。

 #pragma comment(linker,"/STACK:102400000,102400000")//开栈
 //#include <bits/stdc++.h>
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <unordered_map>
 #include <stack>
 #define LL long long
 #define pii pair<int,int>
 using namespace std;
 const int N=+;
 const int INF=0x7f7f7f7f;
 int up;
 int low[N], dfn[N];
 bool iscut[N];
 int dfn_clock, bcc_cnt, bcc_no[N];
 unordered_map<int,int> mapp;
 stack< pii >  stac;
 vector<int> bcc[N], vect[N];

 void DFS(int x, int far)//tarjan
 {
     dfn[x]=low[x]=++dfn_clock;

     int chd=;
     for(int i=; i<vect[x].size(); i++)
     {
         int t=vect[x][i];
         if(!dfn[t])
         {
             chd++;
             stac.push(make_pair(x,t));
             DFS(t,x);
             low[x]=min( low[x], low[t]);
             if(low[t]>=dfn[x])
             {
                 iscut[x]=true;    //需要标记割点
                 bcc[++bcc_cnt].clear();
                 while(true)
                 {
                     int a=stac.top().first;
                     int b=stac.top().second;
                     stac.pop();
                     if(bcc_no[a]!=bcc_cnt)
                     {
                         bcc[bcc_cnt].push_back(a);
                         bcc_no[a]=bcc_cnt;
                     }
                     if(bcc_no[b]!=bcc_cnt)
                     {
                         bcc[bcc_cnt].push_back(b);
                         bcc_no[b]=bcc_cnt;
                     }
                     if(a==x&&b==t)    break;
                 }
             }
         }
         else if( dfn[t]<dfn[x] && t!=far)
         {
             stac.push(make_pair(x,t));
             low[x]=min(low[x],dfn[t]);
         }
     }
     if(chd==&&far==)    iscut[x]=false;        //根
 }

 void find_bcc(int Case)
 {
     memset(low,,sizeof(low));
     memset(dfn,,sizeof(dfn));
     memset(iscut,,sizeof(iscut));
     memset(bcc_no,,sizeof(bcc_no));

     dfn_clock=bcc_cnt=;
     for(int i=; i<=up; i++)    if(!dfn[i])    DFS(i,);   //深搜
     LL ans1=,ans2=;

     for(int i=; i<=bcc_cnt; i++)    //统计度为多少
     {
         int cnt=;
         for(int j=; j<bcc[i].size(); j++)    if(iscut[bcc[i][j] ])    cnt++;    //有割点就统计连通分量i的度。
         if(cnt==)    ans1++, ans2*=bcc[i].size()-;
     }
     if(bcc_cnt==)    ans1=,ans2=(LL)bcc[].size()*(bcc[].size()-)/;
     printf("Case %d: %lld %lld\n", Case, ans1, ans2);
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int a, b, n, j=;
     while(scanf("%d",&n), n)
     {
         mapp.clear();
         for(int i=; i<N; i++)    vect[i].clear();
         up=;
         for(int i=; i<n; i++)
         {
             scanf("%d%d",&a,&b);
             if(!mapp[a])    mapp[a]=++up;
             if(!mapp[b])    mapp[b]=++up;//点号缩小为连续

             vect[mapp[a]].push_back(mapp[b]);
             vect[mapp[b]].push_back(mapp[a]);
         }
         find_bcc(++j);
     }
     return ;
 }

AC代码