[HDU 6200] mustedge mustedge mustedge

题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=6200

题目大意： 给出一个n个点m条边的连通无向图， 有两种操作， 1是新增一条无向边(u, v)， 2是询问u->v的路径上必须经过的边的条数。

思路： 答案就是将环缩点后的树上两点的距离。

先用tarjan缩点求出原图的树，对于每次加边会产生新环， 我们要维护树上两点的距离， 实际上只要维护每个点的深度。 所以对于产生的新环我们无需改变树本身的形态， 只需删除该点对深度的贡献即可。 由于每个点只会被合并一次， 可以直接并查集暴力合并， 每个点对深度的贡献的维护与求值用树链剖分即可。

PS: 线段树原来要开4n的空间， 以前一直开2n为什么没事。。。。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

#define ls (x << 1)
#define rs (x << 1 | 1)
#define mid ((l + r) >> 1) 

using namespace std;

const int N = (int)1e5 + 10;

int n, m, q, edge[N][2];
int cnt, lst[N], to[N << 2], nxt[N << 2];

void add(int u, int v){
    nxt[++ cnt] = lst[u]; lst[u] = cnt; to[cnt] = v;
    nxt[++ cnt] = lst[v]; lst[v] = cnt; to[cnt] = u;
}

int indx, dfn[N], low[N], id[N];
int ttop, stk[N], instk[N];

void tarjan(int u, int pre){
    dfn[u] = low[u] = ++ indx;
    stk[++ ttop] = u; instk[u] = 1;
    id[u] = u;

    for (int j = lst[u]; j; j = nxt[j]){
        int v = to[j];
        if (j == (pre ^ 1)) continue;
        if (!dfn[v]){
            tarjan(v, j); low[u] = min(low[u], low[v]);
        }
        else if (instk[v]) low[u] = min(low[u], dfn[v]);
    }

    if (low[u] == dfn[u]){
        while (stk[ttop] != u){
            id[stk[ttop]] = u;
            instk[stk[ttop]] = 0;
            ttop --;
        }
        instk[u] = 0; ttop --;
    }
}

int rt, fa[N][20], top[N], ch[N], sz[N], L[N], R[N], dep[N];
void dfs1(int u, int pre){
    sz[u] = 1; fa[u][0] = pre; dep[u] = dep[pre] + 1;
    for (int j = lst[u]; j; j = nxt[j]){
        int v = to[j];
        if (v == pre) continue;
        dfs1(v, u); sz[u] += sz[v];
        if (!ch[u] || sz[ch[u]] < sz[v]) ch[u] = v;
    }
}
void dfs2(int u, int pre){
    L[u] = ++ indx;
    top[u] = ch[pre] == u ? top[pre] : u;
    if (ch[u]) dfs2(ch[u], u);
    for (int j = lst[u]; j; j = nxt[j]){
        int v = to[j];
        if (v == pre || v == ch[u]) continue;
        dfs2(v, u);
    }
    R[u] = indx;
}

int lca(int u, int v){
    if (dep[u] < dep[v]) return lca(v, u);
    for (int k = dep[u] - dep[v], j = 0; k; j ++, k >>= 1)
        if (k & 1) u = fa[u][j];

    if (u == v) return u;

    for (int j = 19; j >= 0; j --)
        if (fa[u][j] != fa[v][j])
            u = fa[u][j], v = fa[v][j];

    return fa[u][0];
}

int find(int x){
    if (id[x] == x) return x;
    return id[x] = find(id[x]);
}
void unnion(int u, int v){
    if (find(u) != find(v)){
        id[find(u)] = find(v);
    }
}

int sum[N << 2];
void build(int x, int l, int r){
    if (l == r) {sum[x] = (l != id[rt]); return;}
    build(ls, l, mid); build(rs, mid + 1, r);
    sum[x] = sum[ls] + sum[rs];
}
void modf(int x, int l, int r, int pos){
    sum[x] --;
    if (l == r) return;
    if (pos <= mid) return modf(ls, l, mid, pos);
    return modf(rs, mid + 1, r, pos);
}
int query(int x, int l, int r, int L, int R){
    if (l == L && r == R) return sum[x];
    if (R <= mid) return query(ls, l, mid, L, R);
    if (L > mid) return query(rs, mid + 1, r, L, R);
    return query(ls, l, mid, L, mid) + query(rs, mid + 1, r, mid + 1, R);
}

int getdep(int u){
    if (u == 0) return 0;
    int ret = 0;
    while (u){
        ret += query(1, 1, indx, L[top[u]], L[u]);
        u = fa[top[u]][0];
    }
    return ret;
}

int main(){

    int T; scanf("%d", &T);
    for (int cas = 1; cas <= T; cas ++){
        printf("Case #%d:\n", cas);

        scanf("%d %d", &n, &m);

        cnt = 1;
        for (int i = 1; i <= n; i ++) lst[i] = 0;

        for (int i = 1, u, v; i <= m; i ++){
            scanf("%d %d", &u, &v);
            edge[i][0] = u, edge[i][1] = v; add(u, v);
        }

        indx = ttop = 0;
        memset(dfn, 0, sizeof(dfn));
        memset(low, 0, sizeof(low));
        memset(stk, 0, sizeof(stk));
        memset(instk, 0, sizeof(instk));

        tarjan(1, 0);

        cnt = 0;
        for (int i = 1; i <= n; i ++) lst[i] = 0;

        for (int i = 1; i <= m; i ++){
            int u = id[edge[i][0]], v = id[edge[i][1]];
            if (u == v) continue; add(u, v);
        }

        indx = 0;
        memset(ch, 0, sizeof(ch));
        memset(top, 0, sizeof(top));

        rt = id[1];
        dfs1(rt, 0);
        dfs2(rt, 0);

        build(1, 1, indx);

        for (int j = 1; j < 20; j ++)
            for (int i = 1; i <= n; i ++)
                fa[i][j] = fa[fa[i][j - 1]][j - 1];

        scanf("%d", &q);
        for (int i = 1, opt, u, v; i <= q; i ++){
            scanf("%d %d %d", &opt, &u, &v);
            u = find(u), v = find(v);
            int Lca = find(lca(u, v));

            if (opt == 1){
                if (u != v){

                    while (u != Lca){
                        unnion(u, find(fa[u][0]));
                        modf(1, 1, indx, L[u]);
                        u = find(fa[u][0]);
                    }

                    while (v != Lca){
                        unnion(v, find(fa[v][0]));
                        modf(1, 1, indx, L[v]);
                        v = find(fa[v][0]);
                    }
                }
            }
            else printf("%d\n", getdep(u) + getdep(v) - getdep(Lca) * 2);
        }

    }

    return 0;
}