loj2048 「HNOI2016」最小公倍数

link

题意：

给定一张$N$个顶点$M$条边的无向图（顶点编号为$1,2,...,n$），每条边上带有权值。所有权值都可以分解成$2^a \cdot 3^b$的形式。

现在有$q$个询问，每次询问给定$u,v,a,b$，请你求出是否存在一条顶点$u$到$v$之间的路径，使得路径依次经过的边上的权值的最小公倍数为$2^a \cdot 3^b$？路径可以不是简单路径。

$n,q\leq 5\times 10^4,m\leq 10^5.$

题解：

我们用qx,qy,qa,qb表示询问中的x,y,a,b，ex,ey,ea,eb表示某条边的x,y,a,b。

如何处理一个询问？将ea,eb分别小于等于qa,qb的边连接起来，若满足qx,qy连通且$\max\{ea\}=qa\&\&\max\{eb\}=qb$，则答案为Yes，否则为No。可以用并查集维护。

多个询问怎么办呢？离线。

一个分块的思路，将a分成若干块，每次处理a在当前块范围内的询问。首先询问按照b排序，对于一个询问qa,qb，我们要找所有$ea\leq qa\&\& eb\leq qb$的边，把它们连起来。

设当前块a的范围为$[L,R)$，两种情况：

1. $ea<L$，将ea在$[1,L)$的边按eb排序，那么只要扫过去就行了;
2. $L\leq ea<R$，暴力枚举合法的边插入，然后暴力退回，用一个栈维护要退回的信息;

使用无路径压缩并查集按秩合并即可。

复杂度$\mathcal{O}(\sqrt{m}(n+q\log n))$。

code:

 #pragma GCC optimize("Ofast")
 #include<bits/stdc++.h>
 #define rep(i,x,y) for (register int i=(x);i<=(y);i++)
 using namespace std;
 char gc(){
     static char buf[],*p1=buf,*p2=buf;
     return p1==p2&&(p2=(p1=buf)+fread(buf,,,stdin),p1==p2)?EOF:*p1++;
 }
 inline int read(){
     char ch=gc(); register int x=;
     for (;!isdigit(ch);ch=gc());
     for (;isdigit(ch);ch=gc()) x=x*+ch-;
     return x;
 }
 const int N=1e5+;
 int n,m,Q,blo,top,x,y,sz,a,b,fa[N],mxa[N],mxb[N],siz[N]; bool ans[N];
 struct node{
     int x,y,a,b,id;
     void rd(){ x=read(),y=read(),a=read(),b=read(); }
     node(){} node(int _x,int _y,int _a,int _b,int _id){ x=_x,y=_y,a=_a,b=_b,id=_id; }
 }e[N],q[N],nq[N],stk[N];
 inline void up(register int &x,register int y){ x=max(x,y); }
 inline bool cmp_a(const node &x,const node &y){ return x.a<y.a||x.a==y.a&&x.b<y.b; }
 inline bool cmp_b(const node &x,const node &y){ return x.b<y.b||x.b==y.b&&x.a<y.a; }
 inline int getfa(register int x){ return x==fa[x]?x:getfa(fa[x]); }
 inline void mer(register int x,register int y,register int a,register int b){
     x=getfa(x),y=getfa(y);
     if (siz[x]>siz[y]) swap(x,y);
     stk[++top].x=x; stk[top].y=y; stk[top].a=mxa[y]; stk[top].b=mxb[y]; stk[top].id=siz[y];
     if (x!=y) fa[x]=y,siz[y]+=siz[x],up(mxa[y],mxa[x]),up(mxb[y],mxb[x]);
     up(mxa[y],a); up(mxb[y],b);
 }
 int main(){
     n=read(),m=read();
     rep (i,,m) e[i].rd();
     sort(e+,e++m,cmp_a); e[m+].a=1e9;
     Q=read();
     rep (i,,Q) q[i].rd(),q[i].id=i;
     sort(q+,q++Q,cmp_b);//事先将询问按照b排序，方便之后处理
     for (register int L=,R,Top,blo=sqrt(*m);L<=m;L+=blo){//按照a分为sqrt个块
         R=min(L+blo,m+); Top=top=;
         rep (i,,n) fa[i]=i,mxa[i]=mxb[i]=-,siz[i]=;
         rep (i,,Q)//提取a在当前块的询问
             if (e[L].a<=q[i].a&&q[i].a<e[R].a) nq[++Top]=q[i];
         if (!Top) continue;
         if (L>) sort(e+,e+L,cmp_b);//a<当前块的边按照b排序
         for (register int i=,j=;i<=Top;i++){
             for (;j<L&&e[j].b<=nq[i].b;j++)//插入a<当前块的边
                  mer(e[j].x,e[j].y,e[j].a,e[j].b);
             top=;
             rep (k,L,R)
                 if (e[k].a<=nq[i].a&&e[k].b<=nq[i].b)//插入当前块的合法边
                     mer(e[k].x,e[k].y,e[k].a,e[k].b);
             x=getfa(nq[i].x),y=getfa(nq[i].y);
             ans[nq[i].id]|=x==y&&mxa[x]==nq[i].a&&mxb[x]==nq[i].b;
             for (;top;top--){//退回
                 x=stk[top].x,y=stk[top].y;
                 fa[x]=x; siz[y]=stk[top].id;
                 mxa[y]=stk[top].a; mxb[y]=stk[top].b;
             }
         }
     }
     rep (i,,Q) puts(ans[i]?"Yes":"No");
     return ;
 }

易错：

没错你会发现我代码里的明显卡常痕迹。。。

艰辛卡常后的我……发现一个致命的错误：“提取a在当前块的询问”这部分，必须写q[i].a<e[R].a，不能改成q[i].a<=e[R-1].a。

考虑一种极端情况，所有边和询问的a全相等，时间复杂度直接退化成$n^2$。