HDU 3844 Mining Your Own Business（割点，变形，开栈，经典）

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

思路：

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

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

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

  1 #pragma comment(linker,"/STACK:102400000,102400000")//开栈
  2 //#include <bits/stdc++.h>
  3 #include <iostream>
  4 #include <cstdio>
  5 #include <cstring>
  6 #include <algorithm>
  7 #include <vector>
  8 #include <unordered_map>
  9 #include <stack>
 10 #define LL long long
 11 #define pii pair<int,int>
 12 using namespace std;
 13 const int N=100000+5;
 14 const int INF=0x7f7f7f7f;
 15 int up;
 16 int low[N], dfn[N];
 17 bool iscut[N];
 18 int dfn_clock, bcc_cnt, bcc_no[N];
 19 unordered_map<int,int> mapp;
 20 stack< pii >  stac;
 21 vector<int> bcc[N], vect[N];
 22
 23 void DFS(int x, int far)//tarjan
 24 {
 25     dfn[x]=low[x]=++dfn_clock;
 26
 27     int chd=0;
 28     for(int i=0; i<vect[x].size(); i++)
 29     {
 30         int t=vect[x][i];
 31         if(!dfn[t])
 32         {
 33             chd++;
 34             stac.push(make_pair(x,t));
 35             DFS(t,x);
 36             low[x]=min( low[x], low[t]);
 37             if(low[t]>=dfn[x])
 38             {
 39                 iscut[x]=true;    //需要标记割点
 40                 bcc[++bcc_cnt].clear();
 41                 while(true)
 42                 {
 43                     int a=stac.top().first;
 44                     int b=stac.top().second;
 45                     stac.pop();
 46                     if(bcc_no[a]!=bcc_cnt)
 47                     {
 48                         bcc[bcc_cnt].push_back(a);
 49                         bcc_no[a]=bcc_cnt;
 50                     }
 51                     if(bcc_no[b]!=bcc_cnt)
 52                     {
 53                         bcc[bcc_cnt].push_back(b);
 54                         bcc_no[b]=bcc_cnt;
 55                     }
 56                     if(a==x&&b==t)    break;
 57                 }
 58             }
 59         }
 60         else if( dfn[t]<dfn[x] && t!=far)
 61         {
 62             stac.push(make_pair(x,t));
 63             low[x]=min(low[x],dfn[t]);
 64         }
 65     }
 66     if(chd==1&&far==0)    iscut[x]=false;        //根
 67 }
 68
 69 void find_bcc(int Case)
 70 {
 71     memset(low,0,sizeof(low));
 72     memset(dfn,0,sizeof(dfn));
 73     memset(iscut,0,sizeof(iscut));
 74     memset(bcc_no,0,sizeof(bcc_no));
 75
 76     dfn_clock=bcc_cnt=0;
 77     for(int i=1; i<=up; i++)    if(!dfn[i])    DFS(i,0);   //深搜
 78     LL ans1=0,ans2=1;
 79
 80     for(int i=1; i<=bcc_cnt; i++)    //统计度为多少
 81     {
 82         int cnt=0;
 83         for(int j=0; j<bcc[i].size(); j++)    if(iscut[bcc[i][j] ])    cnt++;    //有割点就统计连通分量i的度。
 84         if(cnt==1)    ans1++, ans2*=bcc[i].size()-1;
 85     }
 86     if(bcc_cnt==1)    ans1=2,ans2=(LL)bcc[1].size()*(bcc[1].size()-1)/2;
 87     printf("Case %d: %lld %lld\n", Case, ans1, ans2);
 88 }
 89
 90
 91 int main()
 92 {
 93     freopen("input.txt", "r", stdin);
 94     int a, b, n, j=0;
 95     while(scanf("%d",&n), n)
 96     {
 97         mapp.clear();
 98         for(int i=1; i<N; i++)    vect[i].clear();
 99         up=0;
100         for(int i=0; i<n; i++)
101         {
102             scanf("%d%d",&a,&b);
103             if(!mapp[a])    mapp[a]=++up;
104             if(!mapp[b])    mapp[b]=++up;//点号缩小为连续
105
106             vect[mapp[a]].push_back(mapp[b]);
107             vect[mapp[b]].push_back(mapp[a]);
108         }
109         find_bcc(++j);
110     }
111     return 0;
112 }

AC代码