hdu 5409 CRB and Graph 2015多校联合训练赛#10 dfs

CRB and Graph

Time Limit: 8000/4000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 238 Accepted Submission(s): 95



Problem Description

A connected, undirected graph of N vertices
and M edges
is given to CRB.

A pair of vertices (u, v)
(u < v)
is called critical for edge e if
and only if u and v become
disconnected by removing e.

CRB’s task is to find a critical pair for each of M edges.
Help him!



Input

There are multiple test cases. The first line of input contains an integer T,
indicating the number of test cases. For each test case:

The first line contains two integers N, M denoting
the number of vertices and the number of edges.

Each of the next M lines
contains a pair of integers a and b,
denoting an undirected edge between a and b.

1 ≤ T ≤
12

1 ≤ N, M ≤ 105

1 ≤ a, b ≤ N

All given graphs are connected.

There are neither multiple edges nor self loops, i.e. the graph is simple.



Output

For each test case, output M lines, i-th
of them should contain two integers u and v,
denoting a critical pair (u, v)
for the i-th
edge in the input.

If no critical pair exists, output "0 0" for that edge.

If multiple critical pairs exist, output the pair with largest u.
If still ambiguous, output the pair with smallest v.



Sample Input

2
3 2
3 1
2 3
3 3
1 2
2 3
3 1

Sample Output

1 2
2 3
0 0
0 0
0 0

Author

KUT（DPRK）



Source

2015 Multi-University Training Contest 10

用dfs先构建一棵树，dfs类似tarjan算法，记录dfn,low值，就知道哪些边是割边。

并且割边一定在树上。同时标记哪些边是树上的边。第二次dfs就对树进行遍历。

在第一次dfs时，需要记录一个子树的第一大，第二大值。但是第一大和第二大的值

不能来自同一棵子树。这样做的目的是在第二次dfs时，当前情况下的最大值和次大值

一定不在同一联通块上。

第二次dfs时，记录两个参数n1,n2. n1是当前结点父亲，孩子，自己的最大值，其实

就是n。n2记录的是当前结点到父亲路径上，经过的所有结点最值，以及这些结点的其他

子树的最值的最值，不包括n1的。对于一条边u-v,如果dfn[v]= low[v]说明是割边，

那么就可以判定了。首先割边分两个连通块，最值分别为n1<n2答案一定是n1,n1+1.

因为n1在一边，n1+1一定在令一边，同时保证了n1是最大的。

对于割边u,v两边取最大值n1, 那么n1=n显然成立，现在就是要确定左右两个连通块谁的

最值较小，判定一下n在哪边，取另外一边的最值即可。

void work(int u,int n1,int n2){
    if(mx[u][0] > n1){
        n2 = n1;
        n1 = mx[u][0];
        if(mx[u][1] > n2)
            n2 = mx[u][1];
    }
    else if(mx[u][1] > n2){
        n2 = mx[u][1];
    }
    int m1,m2;
    for(int i = head[u];i != -1;i = edge[i].next){
        if(edge[i].ok != 2) continue;
        int v = edge[i].v;
        if(low[v] == dfn[v]){
            if(n1 == mx[v][0]){
                m1 = n2;
            }
            else {
                m1 = min(n1,mx[v][0]);
            }
            if(m1 == n) m1 = m2;
            ans[i/2][0] = m1, ans[i/2][1] = m1+1;
        }
        work(v,n1,n2);
    }
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
using namespace std;
#define ll long long
#define maxn 300007
int head[maxn],cnt;
struct Edge{
    int v,next,ok;
};
Edge edge[maxn];
void addedge(int u,int v){
    edge[cnt].v = v;
    edge[cnt].next = head[u];
    edge[cnt].ok = 1;
    head[u] = cnt++;
    edge[cnt].v = u;
    edge[cnt].next = head[v];
    edge[cnt].ok = 1;
    head[v] = cnt++;
}
int low[maxn],dfn[maxn],mx[maxn][2];
int dcnt=0;
void dfs(int u){
    low[u] = dfn[u] = dcnt++;
    mx[u][0]= u;
    for(int i= head[u];i != -1; i=edge[i].next){
        if(edge[i].ok == 0) continue;
        edge[i^1].ok = 0;
        int v = edge[i].v;
        if(low[v] == 0){
            edge[i].ok = 2;
            dfs(v);
            low[u] = min(low[u],low[v]);
            if(mx[v][0] > mx[u][0]){
                mx[u][1] = mx[u][0];
                mx[u][0] = mx[v][0];
            }
            else if(mx[v][0] > mx[u][1]){
                mx[u][1] = mx[v][0];
            }
        }
        else low[u] = min(low[u],low[v]);
    }
}
int ans[maxn][2],n,m;
void work(int u,int n1,int n2){
    if(mx[u][0] > n1){
        n2 = n1;
        n1 = mx[u][0];
        if(mx[u][1] > n2)
            n2 = mx[u][1];
    }
    else if(mx[u][1] > n2){
        n2 = mx[u][1];
    }
    int m1,m2;
    for(int i = head[u];i != -1;i = edge[i].next){
        if(edge[i].ok != 2) continue;
        int v = edge[i].v;
        if(low[v] == dfn[v]){
            if(n1 == mx[v][0]){
                m1 = n1;
                m2 = n2;
            }
            else {
                m1 = max(n1,mx[v][0]);
                m2 = min(n1,mx[v][0]);
            }
            if(m1 == n) m1 = m2;
            ans[i/2][0] = m1, ans[i/2][1] = m1+1;
        }
        work(v,n1,n2);
    }
}

int main(){
    int t,u,v;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        cnt = 0;
        memset(head,-1,sizeof(head));
        for(int i = 0;i < m; i++){
            scanf("%d%d",&u,&v);
            addedge(u,v);
        }
        dcnt = 1;
        memset(low,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        dfs(1);
        memset(ans,0,sizeof(ans));
        work(1,0,0);
        for(int i = 0;i < m; i++)
            printf("%d %d\n",ans[i][0],ans[i][1]);
    }
    return 0;
}