BZOJ4537 [ HNOI2016 ] 最小公倍数 （按轶合并带权并查集+分块离线）

太弱啦，看了题解才知道怎么做
离线算法：
对于单组询问x , y , a , b，我们可以将边权小于a的点全部加入带权并查集，然后判断x,y所在的并查集里面最大的权值是否为b。
对于多组询问，我们采用分块离线的算法。将边权按a为第一关键字升序排序，每k个分一组，总共有m/k组。
对于在这个分组之前的所有分组和当前分组内的边，按b为第一关键字升序排序，记录下在这个块内需要被统计的答案。对块内询问按b为第一关键字升序排序。
对于在这个分组之前的分组，满足任意$e[ i ].a < Q[ j ].a$，故可以按b的顺序加边，每个块内的查询是O(m)。对于在当前分组，每次查询的时候将所有满足 $e[ i ].a <= Q[ j ].a && e[ i ].b <= Q[ j ].b$ 的边加入并查集，并且记录下操作，操作结束之后将这些边从并查集里删除，单次操作 $O(k * log(m))$，每个块内的时间$O(k * k * log(m))$。
最后总时间代价为$O( m/k * (m + (k * k * log(m)) ) )$
整理得：$O(m * ( m / k + k * logm ))$
由均值不等式得：iff $k = \sqrt{ m * log(m) }$ ，不等式取最小值（不知为啥直接取$\sqrt{ m }$会超时）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

#define N 100050
#define M 100050

using namespace std;

struct data{ int u,v,a,b,rank; }e[M],Q[M],tmp[M];
struct Monster{ int x,y,ma,mb,fx,sizy; }hc[N]; 


int fa[N],siz[N],ma[N],mb[N];
bool ans[N];
int n,m,q,k,top,tot;

int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

bool cmpa(data p1,data p2) { return p1.a != p2.a ? p1.a < p2.a : p1.b < p2.b; }
bool cmpb(data p1,data p2) { return p1.b != p2.b ? p1.b < p2.b : p1.a < p2.a; }

int get(int x) {
    if (fa[x] == x) return x; return get( fa[x] );    
}

void go(int g) {
     int x = get( e[g].u ) , y = get( e[g].v );
     if (siz[x] > siz[y]) swap(x,y);
     hc[++tot].x = x;  hc[tot].y = y; 
     hc[tot].ma = ma[y]; hc[tot].mb = mb[y];
     hc[tot].fx = fa[x]; hc[tot].sizy = siz[y];

     if (x == y) {
        ma[x] = max(e[g].a,ma[x]);
        mb[x] = max(e[g].b,mb[x]);
        return ;
     }

     fa[x] = y; siz[y] += siz[x];
     ma[y] = max( max(e[g].a , ma[x]) ,ma[y]);
     mb[y] = max( max(e[g].b , mb[x]) ,mb[y]);

     return ;
}



inline void clean() {
     for (int i=tot;i>=1;i--) {
        int x = hc[i].x;
        int y = hc[i].y;    

        fa[x] = hc[i].fx;
        siz[y] = hc[i].sizy;
        ma[y] = hc[i].ma;
        mb[y] = hc[i].mb;
     }
     tot = 0;
}


int main()
{
    n = read(); m = read();
    for (int i=1;i<=m;i++) {
        e[i].u = read();
        e[i].v = read();
        e[i].a = read();
        e[i].b = read();
        //scanf("%d%d%d%d",&e[i].u,&e[i].v,&e[i].a,&e[i].b);
    }
    q = read();
    for (int i=1;i<=q;i++) {
        Q[i].u = read();
        Q[i].v = read();
        Q[i].a = read();
        Q[i].b = read();
        //scanf("%d%d%d%d",&Q[i].u,&Q[i].v,&Q[i].a,&Q[i].b);
    }
    for (int i=1;i<=q;i++) Q[i].rank = i;

    sort(e+1,e+m+1,cmpa);
    k = sqrt(20*m);

    sort(Q+1,Q+q+1,cmpb);
    for (int i=1;i<=m;i+=k) //查询[i,i+k-1]区间 
    { 
        top = 0;
        for (int j=1;j<=q;j++) //加入块内的边 
            if (Q[j].a >= e[i].a && ( i+k>m || Q[j].a < e[i+k].a ) )
                tmp[ ++top ] = Q[j];
        sort(e+1,e+i,cmpb); //将块之前的边排序
        for (int j=1;j<=n;j++) //初始化并查集 
            fa[j] = j , siz[j] = 1 , ma[j] = -1 , mb[j] = -1;
        int g = 1;
        for (int j=1;j<=top;j++) {
            //for (;g<i && e[g].b <= tmp[j].b;g++) go(g); 
            while (g<i && e[g].b <= tmp[j].b) go(g++);
            tot = 0; //清空并查集记录 
            for (int t=i;t<=min(i+k-1,m);t++) 
                if (e[t].a <= tmp[j].a && e[t].b <= tmp[j].b)
                    go(t);
            int x = get(tmp[j].u);
            int y = get(tmp[j].v);
            if (x == y && ma[x] == tmp[j].a && mb[x] == tmp[j].b)
                ans[ tmp[j].rank ] = true;
            else
                ans[ tmp[j].rank ] = false;

            clean();//清除并查集 
        }
    }

    for (int i=1;i<=q;i++) 
        if (ans[i])
            puts("Yes");
        else
            puts("No");


    return 0;
}