HDU 5409 CRB and Graph 【点双连通+DFS】

<题目链接>

题目大意：

　　给你一个连通的无向图，问你删除每一条边后，是否能够出现一对(u,v)，使得u,v不连通，且u<v，如果有多对u,v,则输出尽量大的u，和尽量小的v。

解题分析：
　　首先要明确，因为该图是连通的无向图，所以删除的边是桥才能够使至少两点不连通。但是对于删除桥的情况，如何输出尽可能大的u和尽可能小的v呢？

　　我们要知道，删除一个桥，是将整张图分成两部分，这两部分的点仍然是连通的，并且，由于题目要求u<v，且u尽可能的大，v尽可能的小，所以，我们可以推断出，u与n一定不在同一部分，并且u是它所属部分的最大值，同时由于所有点的序号是连续的，u是那一部分的最大值，所以v的值一定是u+1。所以本题的目标就已经很明确了，就是先对每个点双连通分量进行缩点，并且维护每个连通分量的最大值。最后寻找u值得时候，就直接用DFS寻找不含n点的部分的最大值即可。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 const int MAXN = 1e5+;
 #define clr(a,b) memset(a,b,sizeof(a))
 struct Edge{
     int to,next;
     bool vis,bridge;
     Edge(){}
     Edge(int _to,int _next):to(_to),next(_next){vis=false;bridge=false;}
 }e[MAXN<<];
 int times,n,m,top,bcc,tot;
 int dfn[MAXN],low[MAXN],pre[MAXN],head[MAXN],stk[MAXN],belong[MAXN],res[MAXN];
 void init(){
     top=times=bcc=tot=;
     clr(head,-);clr(dfn,);clr(low,);clr(belong,);clr(pre,);
 }
 void addedge(int u,int v){
     e[tot]=Edge(v,head[u]);head[u]=tot++;
     e[tot]=Edge(u,head[v]);head[v]=tot++;
 }
 void Tarjan(int u){
     dfn[u]=low[u]=++times;
     stk[++top]=u;
     for(int i=head[u];i!=-;i=e[i].next){
         int v=e[i].to;
         if(e[i].vis)continue;
         e[i].vis=e[i^].vis=true;     //将正反边全部标记
         if(!dfn[v]){
             pre[v]=u;      //记录下父亲节点
             Tarjan(v);
             low[u]=min(low[u],low[v]);
         }
         else if(!belong[v])low[u]=min(low[u],dfn[v]);
     }
     if(dfn[u]==low[u]){
         bcc++;
         res[bcc]=-;     //进行初始化
         belong[u]=bcc;
         while(true){
             int v = stk[top--];
             belong[v]=bcc;
             res[bcc]=max(res[bcc],v);     //维护连通分量中的最大值
             if(v==u)break;
         }
     }
 }
 Edge edg[MAXN*];
 int dep[MAXN],val[MAXN],head1[MAXN],tot1;
 void init1(){
     tot1=;
     clr(head1,-);clr(dep,);
 }
 void AddEdge(int u,int v){
     edg[tot1]=Edge(v,head1[u]);head1[u]=tot1++;
     edg[tot1]=Edge(u,head1[v]);head1[v]=tot1++;
 }
 void dfs(int u,int d){    //得到以u为根的子树中编号最大的节点，并且得到每个节点的深度
     dep[u]=d;
     val[u]=res[u];
     for(int i=head1[u];~i;i=edg[i].next){
         int v=edg[i].to;
         if(!dep[v]){
             dfs(v,d+);
             val[u]=max(val[u],val[v]);    //val[u]为以u为根的子树中最大的编号
         }
     }
 }
 void solve(){
     Tarjan();
     for(int i=;i<tot;i++){     //遍历所有的边
         if(e[i].bridge)continue;
         int u=e[i].to,v=e[i^].to;
         if(pre[v]==u&&dfn[u]<low[v]){    //如果u为v的父亲，且dfn[u]<low[v]，说明u、v之间为桥
             e[i].bridge=e[i^].bridge=true;  //标记该边是否为桥
         }
     }
     init1();     //为缩点后重新构图进行初始化
     for(int i=;i<tot;i+=){
         int u=e[i].to,v=e[i^].to;
         if(belong[u]!=belong[v]){
             AddEdge(belong[u],belong[v]);     //缩点后进行重新构图
         }
     }
     dfs(belong[n],);    //以包含n的点双连通分量为树根
     for(int i=;i<tot;i+=){
         int u=e[i].to,v=e[i^].to;
         if(e[i].bridge){   //因为肯定是两边中深度更浅的节点为根的子树中包含n节点，所以直接输出以深度更深的节点为根的最大值和这个最大值+1(这个最大值相当于是u,因为v>u，并且v要最小所以v为u+1)
             if(dep[belong[u]]>dep[belong[v]])printf("%d %d\n",val[belong[u]],val[belong[u]]+);
             else printf("%d %d\n",val[belong[v]],val[belong[v]]+);
         }
         else printf("0 0\n");     //如果不是桥,则输出0 0
     }
 }
 int main(){
     int T;scanf("%d",&T);
     while(T--){
         scanf("%d%d",&n,&m);
         init();
         for(int i=,x,y;i<m;i++){
             scanf("%d%d",&x,&y);
             addedge(x,y);
         }
         solve();
     }
     return ;
 }

2018-12-04