hdu6200 mustedge mustedge mustedge

这个题好像链剖会T。然后后来学习了一下姿势。
见https://post.icpc-camp.org/d/724-hdoj-6200-mustedge-mustedge-mustedge/6

然后我就实现了一下叉姐说的。

一开始addedge那边写炸了。然后一直T，后来冷静了一下发现有问题。

然后求lca由于内存的原因，我现在一般都用链剖了。

#include 
#include 
#include 
#include 
#include 

using namespace std;

const int maxn = 1e5 + 5;

int f[maxn];
int d[maxn];
vector<int> G[maxn];
//并查集部分
void init(int n){
    for(int i = 1;i <= n;i++){
        f[i] = i;
    }
}

int Find(int x){
    return f[x] == x ? x : f[x] = Find(f[x]);
}

void Union(int u,int v){
    int fx = Find(u);
    int fy = Find(v);
    if(fx == fy) return;
    f[fx] = fy;
}
bool same(int x,int y){
    return Find(x) == Find(y);
}
int n,m;

vectorint,int> > edge;
//树链剖分求lca
int tl[maxn],tr[maxn],tot;
int fa[maxn],sz[maxn],son[maxn];
int top[maxn];
void dfs(int u,int father,int dep){
    tl[u] = ++tot;
    d[u] = dep;
    fa[u] = father;
    son[u] = -1;
    sz[u] = 1;
    for(auto v : G[u]){
        if(v == father) continue;
        dfs(v,u,dep + 1);
        sz[u] += sz[v];
        if(son[u] == -1 || sz[son[u]] < sz[v]){
            son[u] = v;
        }
    }
    tr[u] = tot;
}
void dfs1(int u,int tp){
    top[u] = tp;
    if(son[u] == -1) return;
    dfs1(son[u],tp);
    for(auto v : G[u]){
        if(v == fa[u] || v == son[u]) continue;
        dfs1(v,v);
    }
}

int lca(int u,int v){
    while(top[u] != top[v]){
        if(d[top[u]] < d[top[v]]){
            swap(u,v);
        }
        u = fa[top[u]];
    }
    if(d[u] > d[v]) swap(u,v);
    return u;
}

int c[maxn];
//树状数组实现区间修改单点查询
void add(int x,int d){
    for(int i = x;i <= tot;i += i & -i){
        c[i] += d;
    }
}

void update(int l,int r,int d){
    add(l,d);add(r + 1,-d);
}

int sum(int x){
    int ret = 0;
    for(int i = x;i > 0;i -= i & -i){
        ret += c[i];
    }
    return ret;
}

//树上加边之后并查集暴力修改
void addedge(int u,int v){
    u = Find(u),v = Find(v);
    int anc = Find(lca(u,v));
    while(Find(u) != Find(anc)){
        update(tl[Find(u)],tr[Find(u)],1);
        Union(Find(u),fa[Find(u)]);
    }
    while(Find(v) != Find(anc)){
        update(tl[Find(v)],tr[Find(v)],1);
        Union(Find(v),fa[Find(v)]);
    }
}

int main(){
    int T;
    cin >> T;
    int cas = 0;
    while(T--){
        cin >> n >> m;
        edge.clear();
        init(n);
        for(int i = 1;i <= n;i++)
            G[i].clear();
        for(int i = 1;i <= m;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            if(same(u,v)) edge.push_back(make_pair(u,v));
            else Union(u,v),G[u].push_back(v),G[v].push_back(u);
        }

        tot = 0;  //dfs序部分
        dfs(1,1,1);
        dfs1(1,1);
        for(int i = 1;i <= tot;i++){
            c[i] = 0;
        }
        init(n);
        //  cout << edge.size() << endl;
        for(auto p : edge){
            int u = p.first,v = p.second;
            addedge(u,v);
        }
        printf("Case #%d:\n",++cas);
        int q;
        scanf("%d",&q);
        for(int i = 1;i <= q;i++){
            int opt;
            scanf("%d",&opt);
            if(opt == 1){
                int u,v;
                scanf("%d%d",&u,&v);
                addedge(u,v);
            }
            else{
                int u,v;
                scanf("%d%d",&u,&v);
                int w = lca(u,v);
                int ans = d[u] + d[v] - d[w] * 2 - (sum(tl[u]) + sum(tl[v]) - 2 * sum(tl[w]));
                printf("%d\n",ans);
            }
        }
    }
    return 0;
}