LA 5135 Mining Your Own Business

这是一个bcc题目 。
建图模型是：在一个无向图上 ， 选择尽量少的点涂黑 ， 使得任意删除一个点 ， 每个连通分量都至少有一个黑点 。

所有 ，  可以发现 ， 如果把割点涂黑是不划算的 。 因此有两种方法。
1、用dfs求出所以割点 ， 然后再用bfs进行遍历（不能经过割点） ， 每次遍历出一个连通图 ， 如果这个图只有1个割点 ， 那么标记一个 ， 如果超过1个黑点， 就不要标记 ， 因为 ， 每次只删除 一个割点 ， 所有当这个连通图连接了两个割点时 ， 就一点可以到达其他黑点 。 而如果整个图都没有黑点 ， 则不需要遍历 ， 可知只有2个黑点 。
2、先求出这个图中的所有bcc ， 就判断每个bcc ， 如果这个bcc只有1个割点 ， 那就要标记1个黑点 ， 其他的则不需要进行标记 。

代码 ：
1、
#include
#include
#include
#include
using namespace std ;

const int MAXN = 200100;
vectorgrap[MAXN] ;
int pre[MAXN] , iscut[MAXN];
int n = 0, m = 0, dfs_clock = 0;
int bz[MAXN] , d = 0 , f = 1 , bz2[MAXN];

int dfs(int u ,int  fu)
{
      int lowu = pre[u] = ++dfs_clock;
      int child = 0;
      for(int i = 0 ; i < grap[u].size() ; i++)
      {
            int v = grap[u][i] ;
            if(!pre[v])
            {
                  child += 1;
                  int lowv = dfs(v , u);
                  if(lowv < lowu)  lowu = lowv;
                  if(lowv >= pre[u])
                  {
                        iscut[u] = 1;
                        d += 1;
                        bz[u] = 1;
                  }
            }
            else if(pre[v] < pre[u] && v != fu)
            {
                  if(pre[v] < lowu)
                        lowu = pre[v];
            }
      }
      if( fu < 0 && child == 1)
      {
            if(iscut[u] == 1)
            {
                  d -= 1;
                  iscut[u] = 0 ;
                  bz[u] = 0;
            }
      }
      return lowu;
}

void dfs_find(int u)
{

      for(int i = 0 ; i < grap[u].size() ; i++)
      {
            int v = grap[u][i];
            if(bz2[v]==0 && iscut[v])
            {
                  d += 1;
                  bz2[v] = 1 ;
            }
            if(bz[v] == 0)
            {
                  f += 1;
                  bz[v] = 1;
                  dfs_find(v);
            }
      }
}

int main()
{
      int p = 1;
      while(scanf("%d" , &n) != EOF)
      {
            if(!n)  break ;
            int i  , x , y , j;
            for(i = 1; i <= m; i++)
                  grap[i].clear();
            m = 0;
            for(i = 0 ; i < n; i++)
            {
                  scanf("%d %d" , &x , &y);
                  grap[x].push_back(y);
                  grap[y].push_back(x);
                  if(x < y)  x = y;
                  if(x > m)  m = x;
            }
           
            memset(pre , 0 , sizeof(pre));
            memset(iscut , 0 , sizeof(iscut));
            memset(bz , 0 , sizeof(bz));
            dfs_clock = 0 ;
            d = 0 ;

            dfs(1 , -1);

            long long min = 0 , sum = 1;
            if(d == 0)
            {
                  printf("Case %d: %lld %lld\n" , p++ , 2 ,(long long)m*(m-1)/2);
            }
            else
            {
                  for(i = 1; i <= m; i++)
                  {
                        if(!bz[i])
                        {
                              memset(bz2 , 0 , sizeof(bz2));
                              f = 1;
                              d = 0;
                              bz[i] = 1;
                              dfs_find(i);
                              if(d <= 1)
                              {
                                    min += 1;
                                    sum *=(long long)f;
                              }
                        }
                  }
                  printf("Case %d: %lld %lld\n" , p++ , min , sum);
            }
      }
      return 0;
}

2、

#include
#include
#include
#include
#include
using namespace std;

const int MAXN =200100 ;
vectorgrap[MAXN] , bcc[MAXN];
int pre[MAXN] , iscut[MAXN];
int dfs_clock = 0, dfs_cut = 0, bccno[MAXN];
int n , m = 0;
stacks , t ;

int dfs(int u , int fu)
{
      int lowu = pre[u] = ++dfs_clock;
      int child = 0;
      for(int i = 0 ; i < grap[u].size() ; i++)
      {
           
            int v = grap[u][i];
            if(!pre[v])
            {     
                  s.push(u);
                  t.push(v);
                  child++;
                  int lowv = dfs(v , u);
                  if(lowv < lowu)
                  lowu = lowv;
                  if(lowv >= pre[u])
                  {
                        iscut[u] = 1;
                        dfs_cut++ ;bcc[dfs_cut].clear();
                        for(; ;)
                        {
                              int x = s.top() , y = t.top(); s.pop() ; t.pop();
                              if(bccno[x] != dfs_cut)  {bcc[dfs_cut].push_back(x) ; bccno[x] = dfs_cut;}
                              if(bccno[y] != dfs_cut)  {bcc[dfs_cut].push_back(y) ; bccno[y] = dfs_cut;}
                              if(x == u && y == v)  break;
                        }
                  }
            }
            else if(pre[v] < pre[u] && v != fu)
            {
                  s.push(u); t.push(v);
                  if(lowu > pre[v])
                  lowu =  pre[v];
            }
      }
      if(fu < 0 && child == 1)  iscut[u] = 0;
      return lowu;
}

int main()
{
      int p = 1;
      while(scanf("%d" , &n) != EOF)
      {
            if(n==0)  break;
            int i ,j , x , y;
            for(i = 1; i <= m ; i++)
                  grap[i].clear();
            m = 0;
            for(i = 0 ; i < n; i++)
            {
                  scanf("%d %d" , &x , &y);
                  grap[x].push_back(y);
                  grap[y].push_back(x);
                  if(x < y)  x = y;
                  if(m < x)  m = x;
            }
            dfs_clock = dfs_cut = 0;
            memset(bccno , 0 , sizeof(bccno));
            memset(pre , 0 , sizeof(pre));
            memset(iscut , 0 , sizeof(iscut));
            dfs(1 , -1);
            int ans1 = 0 , ans2 = 1;
            for(i = 1; i <= dfs_cut; i++)
            {
                  int cut_cnt = 0;
                  for(j = 0 ; j < bcc[i].size() ; j++)
                        if(iscut[bcc[i][j]])  cut_cnt += 1;
                  if(cut_cnt == 1) 
                  {
                        ans1 += 1;
                        ans2 *=(bcc[i].size() - cut_cnt) ;
                  }
            }
            if(dfs_cut == 1)
            {
                  ans1 = 2;
                  ans2 =bcc[1].size()*(bcc[1].size()-1)/2 ;
            }
            printf("Case %d: %lld %lld\n" , p++ , ans1 , ans2);
      }
      return 0;
}