「HNOI2016」最小公倍数 解题报告

「HNOI2016」最小公倍数

考虑暴力，对每个询问，处理出\(\le a,\le b\)的与询问点在一起的联通块，然后判断是否是一个联通块，且联通块\(a,b\)最大值是否满足要求。

然后很显然需要去离线搞一下，考虑定期重构。

具体的，先把边按\(a\)排序，然后每\(S\)分一块。

处理每一块时，把前面所有块的边和权值在这个块内的询问放在一起按\(b\)排序，这个可以用类似归并的思路\(O(n)\)完成。

然后遍历这个排序后的东西，用带权并查集维护联通性。

具体的，如果是边，就在并查集里面加上。

如果是询问，就暴力把块内的\(\le a,\le b\)的边加入并查集，然后询问，询问完了以后撤回。

做完了后对块内按\(b\)去\(sort\)一下，然后和前面的块去合并一下，到下一个块就可以归并了。

考虑复杂度，对每个块有个归并排序预处理并查集之类的是\(O(\frac{n^2}{S})\)，然后对每个询问只会处理一次，复杂度是\(O(nS\log n)\)的

然后不等式一下，算出\(S=\sqrt{\frac{n}{\log n}}\)时，总复杂度\(O(n\sqrt{n\log n})\)

看起来挺美好的，我也是这么算的，但我发现取\(\sqrt n\)时是最快的？？

然后想了一波，对每个块加之前的并查集应该还有个\(\log n\)，总复杂度是\(O(\frac{n^2\log n}{S}+nS\log n)=O(n\sqrt n\log 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

转载于:https://www.cnblogs.com/butterflydew/p/10487454.html