hdu5409 CRB and Graph(bcc)

题目中critical的定义：对于边$e<u, v>$成为critical边的充要条件是删除这条边之后u、v不连通了，由于这图是无向图，所以显然是桥边。然后针对桥边构造一条边，使得删除边$e<u,v>$之后，u、v还是连通的。要求$u \ v,u \lneq v,$u尽量的大，其次v尽量的小。

分析：

1.$e<u,v>$不是桥边，那么就是0 0.
2.$e<u,v>$是桥边，去掉这边之后形成两个连通分量A、B。求出A中的最大节点编号p，B中的最大节点编号q。必然有一个等于n，那么这条构造的边就应该是$e<min(p, q), min(p, q) + 1>$.
3.在缩点后的新图中，从含有n号节点的bcc开始搜索dp[block]纪录的是该节点为跟节点的子树中的最大节点编号，那么答案就是$e<dp[block],dp[block]+1>$.

/*****************************************
Author      :Crazy_AC(JamesQi)
Time        :2016
File Name   :
*****************************************/
// #pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <map>
#include <set>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <climits>
using namespace std;
#define MEM(x,y) memset(x, y,sizeof x)
#define pk push_back
#define lson rt << 1
#define rson rt << 1 | 1
#define bug cout << "BUG HERE\n"
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> ii;
typedef pair<ii,int> iii;
const double eps = 1e-8;
const double pi = 4 * atan(1);
const int inf = 1 << 30;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int nCase = 0;
int dcmp(double x){//精度正负、0的判断
    if (fabs(x) < eps) return 0;
    return x < 0?-1:1;
}
inline int read(){
    char c = getchar();
    while (!isdigit(c)) c = getchar();
    int x = 0;
    while (isdigit(c)) {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}
const int maxn = 1e5 + 10;
struct Edge {
    int u, v, id, nxt;
    Edge() {}
    Edge(int _u,int _v,int _id, int _nxt) : u(_u), v(_v), id(_id), nxt(_nxt) {}
}e[maxn<<2];
int head[maxn], ecnt;
void addedge(int u,int v,int id) {
    e[ecnt] = Edge(u, v, id, head[u]), head[u] = ecnt++;
    e[ecnt] = Edge(v, u, id, head[v]), head[v] = ecnt++;
}
int n, m;
int dfn[maxn], low[maxn], depth;
int belong[maxn], block;
int rec[maxn];//block中的最大值
iii vec[maxn];
int _count;
int in[maxn];
stack<int> st;
int p;
ii ans[maxn];
void dfs(int u,int fa) {
    dfn[u] = low[u] = ++depth;
    in[u] = 1;
    st.push(u);
    int first = 1;
    for (int i = head[u];~i;i = e[i].nxt) {
        int v = e[i].v;
        if (v == fa && first) {first = 0;continue;}
        if (dfn[v] == -1) {
            dfs(v, u);
            low[u] = min(low[u], low[v]);
            if (low[v] > dfn[u]) {
                vec[++_count] = iii(ii(u, v), e[i].id);//bridge
            }
        }else if (in[v]) low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u]) {
        block++;
        while(true) {
            int x = st.top();
            st.pop();
            in[x] = 0;
            rec[block] = max(rec[block], x);//纪录当前分量中的最大节点编号
            belong[x] = block;
            if (x == n) p = block;//含有n的分量编号
            if (x == u) break;
        }
    }
}
void tarjan() {
    memset(dfn, -1,sizeof dfn);
    memset(rec, 0, sizeof rec);
    depth = _count = block = 0;
    for (int i = 1;i <= n;++i)
        if (dfn[i] == -1) dfs(i, -1);
}

vector<ii> G[maxn];

void build() {
    for (int i = 1;i <= block;++i)
        G[i].clear();
    for (int i = 1;i <= _count;++i) {
        int u = belong[vec[i].first.first];
        int v = belong[vec[i].first.second];
        G[u].push_back(ii(v, vec[i].second));
        G[v].push_back(ii(u, vec[i].second));
    }
}

void gao(int u,int fa) {
    int Size = G[u].size();
    for (int i = 0;i < Size;++i) {
        int v = G[u][i].first;
        if (v == fa) continue;
        // rec[u] = max(rec[u], rec[v]);//纪录子树的max
        gao(v, u);
        rec[u] = max(rec[u], rec[v]);
        ans[G[u][i].second] = ii(rec[v],rec[v] + 1);
    }
}


int main(int argc, const char * argv[])
{    
    // freopen("in.txt","r",stdin);
    // freopen("out.txt","w",stdout);
    // clock_t _ = clock();

    int kase;cin >> kase;
    while(kase--) {
        cin >> n >> m;
        memset(head, -1,sizeof head), ecnt = 0;
        int u, v;
        for (int i = 1;i <= m;++i) {
            scanf("%d%d", &u, &v);
            addedge(u, v, i);
        }
        memset(ans, 0, sizeof ans);
        tarjan();
        build();
        gao(p, -1);
        for (int i = 1;i <= m;++i)
            printf("%d %d\n", ans[i].first, ans[i].second);
    }

    // printf("\nTime cost: %.2fs\n", 1.0 * (clock() - _) / CLOCKS_PER_SEC);
    return 0;
}