BZOJ4537 [Hnoi2016]最小公倍数 （可撤销&&可持久化并查集学习笔记）

就是要问能否 找一条路径使得经过的 max{a权值和b权值} 等于给定值。

可以发现对一个query(u,v,A,B)来说只有a<=A&&b<=B的边对答案会产生影响否则一定不会被遍历到，可以考虑排序之后枚举a的值和b的值用并查集维护。

原题有个max{a,b}<=30的部分分估计就是给这个的，然后我就不会做了。

实际上枚举太慢可以考虑分块。把边按a排序之后分成sqrt(m)块，枚举每块i，同时处理一些query（先按B排序），这些询问的A>=max{i之前的块的a},然后把之前的块按b排序之后，边询问边加，由于i里也可能有符合条件的边E，因为query按b排，所以E不一定满足下一个询问的(A,B),需要撤销并查集的合并操作。

有关并查集的撤销

两种方法，一种是每次O(1)撤销一步的简化版，不路径压缩，按秩合并，记录每一次合并前的信息，然后undo的时候根据记录的信息就可以了。
更加详细的讲解看这里:http://www.cnblogs.com/Sdchr/p/6359014.html

第二种就是可持久化啦qwq，因为要写主席树所以没有上面方便，不过可以logn回到任意步的状态，用主席树实现一个可持久化数组即可。

然后就能复杂度$O(m*\sqrt m*\log m)$做啦。

小优化:在当前块没有询问的时候，直接continue;

/**************************************************************
    Problem: 4537
    User: DCOI
    Language: C++
    Result: Accepted
    Time:16164 ms
    Memory:7168 kb
****************************************************************/

//QWsin
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=50000+10;
const int maxq=50000+10;
const int maxm=100000+10;
inline int read()
{
    int ret=0;char ch=getchar();
    while(ch<'0'||ch>'9') ch=getchar();
    for(;ch>='0'&&ch<='9';ch=getchar()) ret=ret*10+ch-'0';
    return ret;
}

int n,m,q;

struct Node{
    int u,v,a,b,id;Node(){}
    inline void input(int i){u=read();v=read();a=read();b=read();id=i;}
    inline bool operator < (const Node &rhs)const{
        return a<rhs.a||(a==rhs.a&&b<rhs.b);  
    }
}e[maxm],ask[maxq],st[maxq];

inline int cmp(const Node &a,const Node &b){
    return a.b<b.b||(a.b==b.b&&a.a<b.a);
}

inline void init_data(){
    cin>>n>>m;
    for(int i=1;i<=m;++i) e[i].input(i);
    sort(e+1,e+m+1);

    cin>>q;
    for(int i=1;i<=q;++i) ask[i].input(i);
    sort(ask+1,ask+q+1,cmp);
}

struct OP{
    int u,v,ma,mb,sz;
    OP(int u=0,int v=0,int ma=0,int mb=0,int sz=0):u(u),v(v),ma(ma),mb(mb),sz(sz){}
}op[maxn];

int p[maxn],sz[maxn],ma[maxn],mb[maxn];
int findset(int x){return x==p[x]?x:findset(p[x]);}

int tot;//在缓冲区的操作 
inline void merge(int u,int v,int a,int b)
{
    u=findset(u);v=findset(v);
    if(sz[u] > sz[v]) swap(u,v); 
    op[++tot]=OP(u,v,ma[v],mb[v],sz[v]);

    if(u==v){
        ma[u]=max(ma[u],a);mb[u]=max(mb[u],b);
        return ;    
    }

    p[u]=v;sz[v]+=sz[u];
    ma[v]=max(ma[v],max(ma[u],a));
    mb[v]=max(mb[v],max(mb[u],b));
}

inline void undo()//撤销在缓冲区的所有操作 
{
    for(;tot;--tot)
    {
        int u=op[tot].u,v=op[tot].v;
        p[u]=u;
        sz[v]=op[tot].sz;
        ma[v]=op[tot].ma;
        mb[v]=op[tot].mb;
    }
}

int ans[maxq];
inline void solve()
{
    int Sz=sqrt(m);
    for(int i=1;i<=m;i+=Sz)
    {
        int top=0;

        for(int j=1;j<=q;++j)
            if(ask[j].a>=e[i].a && (i+Sz>m||ask[j].a<e[i+Sz].a))
                st[++top]=ask[j];

        if(!top) continue;

        sort(e+1,e+i,cmp);

        for(int j=1;j<=n;++j) p[j]=j,sz[j]=1,ma[j]=mb[j]=-1;

        for(int j=1,k=1;j<=top;++j)
        {
            for(;k<i&&e[k].b<=st[j].b;++k)
                merge(e[k].u,e[k].v,e[k].a,e[k].b);

            tot=0;

            for(int p=i;p<i+Sz&&p<=m;++p)
                if(e[p].a<=st[j].a&&e[p].b<=st[j].b)
                    merge(e[p].u,e[p].v,e[p].a,e[p].b);

            int u=findset(st[j].u),v=findset(st[j].v);
            ans[st[j].id]= (u==v && ma[u]==st[j].a && mb[u]==st[j].b);
            undo();
        }
    }
    for(int i=1;i<=q;++i) puts(ans[i]?"Yes":"No");
}

int main()
{
    init_data();
    solve();
    return 0;
}