「HNOI2016」最小公倍数
考虑暴力，对每个询问，处理出(le a,le b)的与询问点在一起的联通块，然后判断是否是一个联通块，且联通块(a,b)最大值是否满足要求。
然后很显然需要去离线搞一下，考虑定期重构。
具体的，先把边按(a)排序，然后每(S)分一块。
处理每一块时，把前面所有块的边和权值在这个块内的询问放在一起按(b)排序，这个可以用类似归并的思路(O(n))完成。
然后遍历这个排序后的东西，用带权并查集维护联通性。
具体的，如果是边，就在并查集里面加上。
如果是询问，就暴力把块内的(le a,le b)的边加入并查集，然后询问，询问完了以后撤回。
做完了后对块内按(b)去(sort)一下，然后和前面的块去合并一下，到下一个块就可以归并了。
考虑复杂度，对每个块有个归并排序预处理并查集之类的是(O(frac{n^2}{S}))，然后对每个询问只会处理一次，复杂度是(O(nSlog n))的
然后不等式一下，算出(S=sqrt{frac{n}{log n}})时，总复杂度(O(nsqrt{nlog n}))
看起来挺美好的，我也是这么算的，但我发现取(sqrt n)时是最快的？？
然后想了一波，对每个块加之前的并查集应该还有个(log n)，总复杂度是(O(frac{n^2log n}{S}+nSlog n)=O(nsqrt nlog n))的，因为上界松所以才跑过去...
然而还有一个问题，如果很多个(a)的权值相同，你又写丑了，会对每个询问处理多次...我一开始就怎么T想了巨久
Code:
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <algorithm>
using std::min;
using std::max;
template <class T>
void read(T &x)
{
x=0;char c=getchar();
while(!isdigit(c)) c=getchar();
while(isdigit(c)) x=x*10+c-'0',c=getchar();
}
const int N=2e5+10;
struct koito_yuu
{
int u,v,a,b,op;
bool friend operator <(koito_yuu a,koito_yuu b){return a.b==b.b?a.op<b.op:a.b<b.b;}
}yuu[N],bee[N],yuy[N],tmp[N];
int n,m,q,ans[N];
bool cmp(koito_yuu a,koito_yuu b){return a.a==b.a?a.b<b.b:a.a<b.a;}
int f[N],h[N],mxa[N],mxb[N],opt[N],ds[N],dh[N],dmxa[N],dmxb[N],tim;
int Find(int x){return f[x]==x?x:Find(f[x]);}
void cop(int u,int v)
{
++tim;
opt[tim]=u,ds[tim]=v,dh[tim]=h[u],dmxa[tim]=mxa[u],dmxb[tim]=mxb[u];
}
void dcop(int t)
{
int u=opt[t];
h[u]=dh[t],mxa[u]=dmxa[t],mxb[u]=dmxb[t],f[ds[t]]=ds[t];
}
void Merge(int u,int v,int a,int b)
{
u=Find(u),v=Find(v);
if(u==v)
{
cop(u,0);
mxa[u]=max(mxa[u],a);
mxb[u]=max(mxb[u],b);
return;
}
if(h[u]<h[v]) std::swap(u,v);
cop(u,v);
f[v]=u;
mxa[u]=max(max(mxa[u],a),mxa[v]);
mxb[u]=max(max(mxb[u],b),mxb[v]);
if(h[u]==h[v]) ++h[u];
}
int main()
{
read(n),read(m);
for(int i=1;i<=m;i++)
{
read(yuu[i].u),read(yuu[i].v);
read(yuu[i].a),read(yuu[i].b);
}
read(q);
for(int i=1;i<=q;i++)
{
read(bee[i].u),read(bee[i].v);
read(bee[i].a),read(bee[i].b);
bee[i].op=i;
}
std::sort(yuu+1,yuu+1+m,cmp);
std::sort(bee+1,bee+1+q);
int B=sqrt(m/log2(n))+1,T=(m-1)/B+1;
for(int k=1;k<=T;k++)
{
int L=B*(k-1)+1,R=min(B*k,m),l1=1,r1=L-1,l2=1,r2=0;
for(int i=1;i<=q;i++)
if(yuu[L].a<=bee[i].a&&(R==m||bee[i].a<yuu[R+1].a))
tmp[++r2]=bee[i];
int cnt=0;
while(l1<=r1&&l2<=r2)
{
if(yuu[l1]<tmp[l2]) yuy[++cnt]=yuu[l1++];
else yuy[++cnt]=tmp[l2++];
}
while(l2<=r2) yuy[++cnt]=tmp[l2++];
for(int i=1;i<=n;i++) f[i]=i,mxa[i]=mxb[i]=-1,h[i]=1;
for(int i=1;i<=cnt;i++)
{
int u=yuy[i].u,v=yuy[i].v,a=yuy[i].a,b=yuy[i].b;
if(yuy[i].op)
{
tim=0;
for(int j=L;j<=R;j++)
if(yuu[j].a<=a&&yuu[j].b<=b)
Merge(yuu[j].u,yuu[j].v,yuu[j].a,yuu[j].b);
int ru=Find(u),rv=Find(v);
ans[yuy[i].op]=(ru==rv)&&(mxa[ru]==a)&&(mxb[ru]==b);
for(int j=tim;j;j--) dcop(j);
}
else Merge(u,v,a,b);
}
std::sort(yuu+L,yuu+R+1);
l1=1,r1=L-1,l2=L,r2=R,cnt=0;
while(l1<=r1&&l2<=r2)
{
if(yuu[l1]<yuu[l2]) tmp[++cnt]=yuu[l1++];
else tmp[++cnt]=yuu[l2++];
}
while(l1<=r1) tmp[++cnt]=yuu[l1++];
while(l2<=r2) tmp[++cnt]=yuu[l2++];
for(int i=1;i<=cnt;i++) yuu[i]=tmp[i];
}
for(int i=1;i<=q;i++) puts(ans[i]?"Yes":"No");
return 0;
}
2019.3.7