关于无向图中连通分量缩点的问题

1、把边-双连通分量合并

一般情况：是要把边-双连通分量合并成一个点 ， 然后用所有的桥组成一个新图 ， 这样得到的新图就是一棵树了

方法：所有点只属于一个双连通分量 ， 所以，对于求边-双连通分量，我们只要把所有桥都标记 ， 然后再用dfs来遍历这图并且不经过桥，那么我们得到的就是一个边-双连通分量，根据这个原理 ， 我们用并查集来标记两个点是不是属于同一个边-双连通分量，如果当前这条边时桥，那么我们就不标记他们，否则我们就把这两个点所属的树合并成一颗树。

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

#define maxn 110
#define min(x , y)  (x)<(y)?(x):(y)
int grap[maxn][maxn] , low[maxn];
int pre[maxn] , edge[maxn*maxn][2];
int n , m;
int dfs_clock , cnt;
int p[maxn];

void init()
{
      memset(grap , 0 , sizeof(grap));
      memset(pre , 0 , sizeof(pre));
      dfs_clock = cnt = 0;
      for(int i = 1; i <= n; i++)
            p[i] = i;
}

int find(int x)
{
      int g = x , h;
      while(p[x] != x)  x = p[x];

      while(p[g] != x)
      {
            h = p[g];
            p[g] = x;
            g = h;
      }

      return x;
}

void Union(int x , int y)
{
      int g = find(x) , h = find(y);
      if(g != h)  p[g] = h;
}

int dfs(int u)
{
      int lowu = low[u] = ++dfs_clock;
      int i , lowv;
      for(i = 1; i <= n; i++)
            if(grap[u][i])
            {
                  grap[u][i] -= 1;
                  grap[i][u] -= 1;
                  if(!pre[i])
                  {
                        pre[i] = 1;
                        lowv = dfs(i);
                        lowu = min(lowv , lowu);
                        if(lowv > low[u]) //记录桥
                              edge[cnt][0] = u , edge[cnt++][1] = i;
                        else Union(u , i);
                  }
                  else if(lowu > low[i])
                        lowu = low[i];
            }

      return lowu;     
}

int main()
{
      int i , j , x , y;
      for(i = 1; i <= n; i++)
            if(!pre[i])
            {
                  pre[i] = 1;
                  dfs(i);
            }
      return 0;
}

2、把点-双连通分量合并

方法：对于点-双连通分量来说 ， 每个割点都是属于多个点-双连通分量，对于这种情况，我们就应该通过记录边来确定连通分量，因为每条边只属于一个点-连通分量，所以我们就用一个stack来存储遍历到的边 ， 每当我们碰到割点时，就把这些边上的所有点存储。

代码：
//对于求割点 ， 有两种标记的方法：1、标记边已经走过的边 ； 2、记录每个点的父亲节点，来判断当前不能被遍历的点是不是父亲节点
int dfs(int u , int fa)
{
      int lowu = low[u] = ++dfs_clock;
      int i , lowv;
      for(i = head[u]; i != -1; i = edge[i].next)
      {
            int v = edge[i].u;
            gh.u = u;
            gh.next = v;
            if(!pre[v])
            {
                  xy.push(gh);
                  pre[v] = 1;
                  lowv = dfs(v , u);
                  lowu = min(lowv , lowu);
                  if(lowv >= low[u])
                  {
                        //cout<<u<<endl;
                        dfs_node++;
                        new_edge[dfs_node].clear();
                        for(;;)
                        {
                              node cf = xy.top();  xy.pop();
                              if(p[cf.u] != dfs_node)  
                              {
                                    p[cf.u] = dfs_node ;
                                    new_edge[dfs_node].push_back(cf.u);
                              }
                              if(p[cf.next] != dfs_node)
                              {
                                    p[cf.next] = dfs_node ;
                                    new_edge[dfs_node].push_back(cf.next);
                              }
                              if(cf.u == u && cf.next == v)  break;
                        }
                  }
            }
            else if(v != fa && low[u] > low[v])
            {
                  lowu = min(lowu , low[v]) ; //这里这条边，可记录 ， 也可不记录
                  xy.push(gh);
            }
      }

      return lowu;
}