Gym 100814C Connecting Graph 并查集+LCA

Description

standard input/output 
Statements

Alex is known to be very clever, but Walter does not believe that. In order to test Alex, he invented a new game. He gave Alex nnodes, and a list of queries. Walter then gives Alex one query every second, there are two types of queries:

 means: adding an undirected edge between nodes u and v.

 means: what was the earliest time (query index) when u and v became connected? 2 nodes are connected if there is a path of edges between them. Alex can solve this problem easily, but he is too busy now, so he is asking for your help.

Input

The first line contains an integer T, the number of test cases. Each test case begins with a line containing two integers (1 ≤ n, m ≤ 10⁵), the number of nodes and queries, respectively. Then there are m lines, each line represents a query and contains three integers,type, u and v ( , 1 ≤ u, v ≤ n)

Output

For each query of type 2, print one line with one integer, the answer to the query. If the 2 nodes in the query are not connected, print -1.

Sample Input

Input

1
4 5
1 1 2
2 1 2
1 2 3
2 1 3
2 1 4

Output

1
3
-1

Hint

Warning: large Input/Output data, be careful with certain languages.

2016寒假训练04C，赛后补的：题意是给出m中操作，分别是1, u, v，既节点u,v之间连一条边，2, u, v即询问是最早是第几次操作使得u，v联通

可以用并查集维护连通性，如果(u, v)已经联通，那么对于操作1，(u,v)就不再连边，这样对于每一个联通块得到的是一颗树，所有的联通块对应于森林

维护mx[u][i]表示节点u到其第2^i个祖先之间边权的最大值，这样在查询lca的时候就能得到u, v之间路径的最大边权，就是对应于2的答案

#include <bits/stdc++.h>
using namespace std;
const int N = ;
const int DEG = ;
typedef pair<int, int> pii;
int head[N], tot;
struct Edge {
    int v, w, next;
    Edge() {}
    Edge(int v, int w, int next) : v(v), w(w), next(next) {}
}e[N << ];
struct Query {
    int u, v, w;
    Query() {}
    Query(int u, int v, int w) : u(u), v(v), w(w) {}
}q[N];
int f[N][DEG + ], mx[N][DEG + ], fa[N], deg[N];
void init(int n) {
    for(int i = ; i <= n; ++i) fa[i] = i;
    memset(head, -, sizeof head);
    tot = ;
}
void add(int u, int v, int w) {
    e[tot] = Edge(v, w, head[u]);
    head[u] = tot++;
}
int find(int x) {
    return fa[x] == x ?
    x : fa[x] = find(fa[x]);
}
void BFS(int rt) {
    queue<int> que;
    deg[rt] = ;
    f[rt][] = rt;
    mx[rt][] = ;
    que.push(rt);
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = ; i < DEG; ++i) {
            f[u][i] = f[f[u][i - ]][i - ];
            mx[u][i] = max(mx[u][i - ], mx[f[u][i-]][i-]);
        }
        for(int i = head[u]; ~i; i = e[i].next) {
            int v = e[i].v;
            int w = e[i].w;
            if(v == f[u][]) continue;
            deg[v] = deg[u] + ;
            f[v][] = u;
            mx[v][] = w;
            que.push(v);
        }
    }
}
int getmx(int u, int v) {
    if(deg[u] > deg[v]) swap(u, v);
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v, res = ;
    for(int det = hv - hu, i = ; det; det >>= , ++i) {
        if(det & ) { res = max(res, mx[tv][i]); tv = f[tv][i]; }
    }
    if(tu == tv) return res;
    for(int i = DEG - ; i >= ; --i)
    {
        if(f[tu][i] == f[tv][i]) continue;
        res = max(res, mx[tu][i]);
        res = max(res, mx[tv][i]);
        tu = f[tu][i];
        tv = f[tv][i];
    }
    return max(res, max(mx[tu][], mx[tv][]));
}
int main() {
    int _; scanf("%d", &_);
    while(_ --)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        int u, v, t, num = , res;
        init(n);
        for(int i = ; i <= m; ++i) {
            scanf("%d%d%d", &t, &u, &v);
            if(t == ) {
                int fu = find(u);
                int fv = find(v);
                if(fu == fv) continue;
                fa[fu] = fv;
                add(u, v, i);
                add(v, u, i);
            }else {
                q[num++] = Query(u, v, i);
            }
        }
        for(int i = ; i <= n; ++i) if(fa[i] == i) {
            BFS(i);
        }

        for(int i = ; i < num; ++i) {
            if(q[i].u == q[i].v) puts("");
            else {
                int fu = find(q[i].u);
                int fv = find(q[i].v);
                if(fu != fv) puts("-1");
                else {
                    res = getmx(q[i].u, q[i].v);
                    printf("%d\n", res > q[i].w ? - : res);
                }
            }
        }
    }
}