Noip模拟22 2021.7.21

T1 d

简化题意就是找到相对平均长宽的偏移量较大的矩形给他删掉

可以说是个贪心，按照a，b分别为第一关键字排序

然后假装删去要求的那么多个按a排序的较小的，然后再去b中，

找到 删去的a中的那几个矩形 比 按b排序的却并未删去的矩形 优的加回到最终用的矩形集合中

上述操作用经典指针可以实现。（%%zxs活学活用指针场上A掉此题）

#include<bits/stdc++.h>
#define int long long
using namespace std;
inline 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<<1)+(x<<3)+(ch^48); ch=getchar(); }
    return x*f;
}
inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
const int NN=1e5+5,inf=1e18;
int T,n,m,cnt,ita,itb,ans,tmp;
int ta[NN],tb[NN];
bool vis[NN];
struct node{int a,b,id;}s[NN],aa[NN],bb[NN];
inline bool cmp1(node x,node y){return x.a==y.a? x.b<y.b:x.a<y.a;}
inline bool cmp2(node x,node y){return x.b==y.b? x.a<y.a:x.b<y.b;}
inline void clear(){
    memset(vis,0,sizeof(vis));
    memset(ta,0,sizeof(ta));
    memset(tb,0,sizeof(tb));
    ans=0; ita=itb=inf; tmp=1;
}
inline void move(){
    while(!ta[ita]) ita++;
    while(!tb[itb]) itb++;
    ans=max(ans,ita*itb);
}
namespace WSN{
    inline int main(){
        T=read(); if(!T) return 0;
        while(T--){
            clear();
            n=read();m=read();
            for(int i=1;i<=n;i++) s[i].a=read(),s[i].b=read(),s[i].id=i;
            for(int i=1;i<=n;i++){
                aa[i]=s[i]; bb[i]=s[i];
                ta[s[i].a]++; tb[s[i].b]++;
                ita=min(ita,s[i].a); itb=min(itb,s[i].b);
            }
            sort(aa+1,aa+n+1,cmp1); sort(bb+1,bb+n+1,cmp2);
            for(int i=1;i<=m;i++){
                vis[aa[i].id]=1;
                --ta[aa[i].a]; --tb[aa[i].b];
            } move();
            for(int i=1;i<=m;i++){
                if(aa[m-i+1].b<=itb) continue;
                vis[aa[m-i+1].id]=0; ++ta[aa[m-i+1].a]; ++tb[aa[m-i+1].b];
                if(aa[m-i+1].a<ita) ita=aa[m-i+1].a;
                while(vis[bb[tmp].id]) tmp++; --ta[bb[tmp].a]; --tb[bb[tmp].b]; vis[bb[tmp].id]=1;
                move();
            }
            printf("%lld\n",ans);
        }
        return 0;
    }
}
signed main(){return WSN::main();}

T2 e

题目好理解，用：

树链剖分套线段书套平衡树可以解决（Splay没有FHQ—treap更具奇迹性）

我打的Splay无法过掉最大的点，但是JYFHYX打的FHQ—treap却可以

这就是treap的复杂度奇迹性。。。。

#include<bits/stdc++.h>
#define lid (id<<1)
#define rid (id<<1|1)
inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
inline void swap(int &x,int &y){x^=y^=x^=y;}
using namespace std;
inline 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<<1)+(x<<3)+(ch^48); ch=getchar(); }
    return x*f;
}
inline void write(int x){
    if(x<0){ putchar('-'); x=-x;}
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
const int NN=1500000,inf=2e9;
int n,q,typ,a[NN],x[NN],r,k,Q[NN],tot,rt[NN<<2],ans;
int dfn[NN],rk[NN],son[NN],fa[NN],top[NN],siz[NN],dep[NN],cnt;
struct SNOW{int to,next;};SNOW e[NN<<1]; int head[NN],rp;
struct Splay{int son[2],fa,cnt,siz,val;}s[NN];
inline void add(int x,int y){
    e[++rp]=(SNOW){y,head[x]};head[x]=rp;
    e[++rp]=(SNOW){x,head[y]};head[y]=rp;
}
inline void dfs1(int f,int x){
    siz[x]=1;dep[x]=dep[f]+1;fa[x]=f;
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y==f) continue;
        dfs1(x,y); siz[x]+=siz[y];
        if(siz[son[x]]<siz[y]) son[x]=y;
    }
}
inline void dfs2(int x,int t){
    top[x]=t; dfn[x]=++cnt; rk[cnt]=x;
    if(!son[x]) return;
    dfs2(son[x],t);
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y!=fa[x]&&y!=son[x]) dfs2(y,y);
    }
}
inline int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    return x;
}
struct SPLAY{
    void pushup(int x){s[x].siz=s[s[x].son[0]].siz+s[s[x].son[1]].siz+s[x].cnt;}
    int get(int x){return x==s[s[x].fa].son[1];}
    void rotate(int x){
        int y=s[x].fa,z=s[y].fa,xpos=get(x),ypos=get(y);
        s[z].son[ypos]=x; s[x].fa=z;
        s[y].son[xpos]=s[x].son[xpos^1]; s[s[x].son[xpos^1]].fa=y;
        s[x].son[xpos^1]=y; s[y].fa=x;
        pushup(y); pushup(x);
    }
    void splay(int x,int goal,int root){
        while(s[x].fa!=goal){
            int y=s[x].fa,z=s[y].fa,xpos=get(x),ypos=get(y);
            if(z!=goal){
                if(xpos==ypos) rotate(y);
                else rotate(x);
            }rotate(x);
        }if(!goal) rt[root]=x;
    }
    void insert(int val,int root){
        int u=rt[root],fa=0;
        while(u && s[u].val!=val) fa=u,u=s[u].son[val>s[u].val];
        if(u) s[u].cnt++;
        else{
            u=++tot;
            if(fa) s[fa].son[val>s[fa].val]=u;
            s[u].son[0]=s[u].son[1]=0; s[u].val=val; s[u].fa=fa;
            s[u].siz=s[u].cnt=1;
        }splay(u,0,root);
    }
    void find_rank(int val,int root){
        int u=rt[root];
        if(!u) return;
        while(s[u].son[val>s[u].val] && val!=s[u].val) u=s[u].son[val>s[u].val];
        splay(u,0,root);
    }
    int prenxt(int val,int op,int root){
        find_rank(val,root);int u=rt[root];
        if(s[u].val>=val && op) return u;
        if(s[u].val<=val &&!op) return u;
        u=s[u].son[op];
        while(s[u].son[op^1]) u=s[u].son[op^1];
        return u;
    }
}sp;
struct SNOWtree{
    void build(int id,int l,int r){
        sp.insert(inf,id); sp.insert(-inf,id);
        if(l==r) return;
        int mid=l+r>>1;
        build(lid,l,mid); build(rid,mid+1,r);
    }
    void insert(int id,int l,int r,int pos,int val){
        sp.insert(val,id);
        if(l==r) return; int mid=l+r>>1;
        if(pos<=mid) insert(lid,l,mid,pos,val);        
        else insert(rid,mid+1,r,pos,val);
    }
    int pre(int id,int l,int r,int L,int R,int val){
        if(l>R||r<L) return -inf;
        if(L<=l&&r<=R) return s[sp.prenxt(val,0,id)].val;
        int mid=l+r>>1;
        return max(pre(lid,l,mid,L,R,val),pre(rid,mid+1,r,L,R,val));
    }
    int nxt(int id,int l,int r,int L,int R,int val){
        if(l>R||r<L) return inf;
        if(L<=l&&r<=R) return s[sp.prenxt(val,1,id)].val;
        int mid=l+r>>1;
        return min(nxt(lid,l,mid,L,R,val),nxt(rid,mid+1,r,L,R,val));
    }
}tr;
inline int houj(int x,int y,int k){
    int ans=inf;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        ans=min(ans,tr.nxt(1,1,n,dfn[top[x]],dfn[x],k));;
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    ans=min(ans,tr.nxt(1,1,n,dfn[x],dfn[y],k));
    return ans;
}
inline int qian(int x,int y,int k){
    int ans=-inf;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        ans=max(ans,tr.pre(1,1,n,dfn[top[x]],dfn[x],k));
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    ans=max(ans,tr.pre(1,1,n,dfn[x],dfn[y],k));
    return ans;
}
namespace WSN{
    inline int main(){
        // freopen("e7.in","r",stdin);
        // freopen("6.out","w",stdout);
        n=read(); q=read(); typ=read();if(!q) return 0;
        for(int i=1;i<=n;i++) a[i]=read();
        for(int i=1;i<n;i++) add(read(),read());
        dfs1(0,1); dfs2(1,1); tr.build(1,1,n);
        for(int i=1;i<=n;i++) tr.insert(1,1,n,dfn[i],a[i]);
        for(int w=1;w<=q;w++){
            r=read(),k=read();
            for(int i=1;i<=k;i++) Q[i]=x[i]=read();
            if(typ)    for(int i=1;i<=k;i++) Q[i]=(x[i]-1+ans*typ)%n+1;
            ans=inf;
            int Lca=Q[1]; for(int i=2;i<=k;i++) Lca=LCA(Lca,Q[i]);
            for(int i=1;i<=k;i++){
                int pre=qian(Lca,Q[i],r);
                int nxt=houj(Lca,Q[i],r);
                ans=min(ans,min(abs(r-pre),abs(r-nxt)));
            } write(ans); putchar('\n');
        }
        return 0;
    }
}
signed main(){return WSN::main();}

正解是个主席树板子，所以打完这道题后就去打了主席树专题

#include<bits/stdc++.h>
inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
inline void swap(int &x,int &y){x^=y^=x^=y;}
using namespace std;
inline 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<<1)+(x<<3)+(ch^48); ch=getchar(); }
    return x*f;
}
inline void write(int x){
    if(x<0){ putchar('-'); x=-x;}
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
const int NN=100005,inf=2e9;
int n,q,typ,a[NN],x[NN],r,k,Q[NN],tot,ans;
int dfn[NN],rk[NN],son[NN],fa[NN],top[NN],siz[NN],dep[NN],cnt;
int rt[NN];
struct SNOW{int to,next;};SNOW e[NN<<1]; int head[NN],rp;
inline void add(int x,int y){
    e[++rp]=(SNOW){y,head[x]};head[x]=rp;
    e[++rp]=(SNOW){x,head[y]};head[y]=rp;
}
inline void dfs1(int f,int x){
    siz[x]=1;dep[x]=dep[f]+1;fa[x]=f;
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y==f) continue;
        dfs1(x,y); siz[x]+=siz[y];
        if(siz[son[x]]<siz[y]) son[x]=y;
    }
}
inline void dfs2(int x,int t){
    top[x]=t; dfn[x]=++cnt; rk[cnt]=x;
    if(!son[x]) return;
    dfs2(son[x],t);
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y!=fa[x]&&y!=son[x]) dfs2(y,y);
    }
}
inline int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    return x;
}
struct SNOWtree{
    int num,ll[NN*80],rr[NN*80],sum[NN*80];
    inline int New(int x){sum[++num]=sum[x]; ll[num]=ll[x]; rr[num]=rr[x]; return num;}
    inline void pushup(int x){sum[x]=sum[ll[x]]+sum[rr[x]];}
    inline int insert(int id,int l,int r,int pos){
        id=New(id); ++sum[id];
        if(l==r) return id;
        int mid=l+r>>1;
        if(pos<=mid) ll[id]=insert(ll[id],l,mid,pos);
        else rr[id]=insert(rr[id],mid+1,r,pos);
        pushup(id); return id;
    }
    inline int pre(int id1,int id2,int l,int r,int pos){
        if(sum[id1]==sum[id2]) return -inf;
        if(l==r) return l;
        int mid=l+r>>1;
        if(pos<=mid) return pre(ll[id1],ll[id2],l,mid,pos);
        else{
            int tmp=pre(rr[id1],rr[id2],mid+1,r,pos);
            if(tmp!=-inf) return tmp;
            else return pre(ll[id1],ll[id2],l,mid,mid);
        }
    }
    inline int nxt(int id1,int id2,int l,int r,int pos){
        if(sum[id1]==sum[id2]) return inf;
        if(l==r) return l;
        int mid=l+r>>1;
        if(pos>mid) return nxt(rr[id1],rr[id2],mid+1,r,pos);
        else{
            int tmp=nxt(ll[id1],ll[id2],l,mid,pos);
            if(tmp!=inf) return tmp;
            else return nxt(rr[id1],rr[id2],mid+1,r,mid+1);
        }
    }
}tr;
namespace WSN{
    inline int main(){
        // freopen("e7.in","r",stdin);
        // freopen("6.out","w",stdout);
        n=read(); q=read(); typ=read();if(!q) return 0;
        for(int i=1;i<=n;i++) a[i]=read();
        for(int i=1;i<n;i++) add(read(),read());
        dfs1(0,1); dfs2(1,1);
        for(int i=1;i<=n;i++) rt[i]=tr.insert(rt[fa[i]],1,inf,a[i]);
        for(int w=1;w<=q;w++){
            r=read(),k=read();
            for(int i=1;i<=k;i++) Q[i]=x[i]=read();
            if(typ)    for(int i=1;i<=k;i++) Q[i]=(x[i]-1+ans*typ)%n+1;
            ans=inf;
            int Lca=Q[1]; for(int i=2;i<=k;i++) Lca=LCA(Lca,Q[i]);
            for(int i=1;i<=k;i++){
                int pre=tr.pre(rt[fa[Lca]],rt[Q[i]],1,inf,r);
                int nxt=tr.nxt(rt[fa[Lca]],rt[Q[i]],1,inf,r);
                //cout<<"pre="<<pre<<endl;
                //cout<<"nxt="<<nxt<<endl;
                ans=min(ans,min(abs(r-pre),abs(r-nxt)));
            } write(ans); putchar('\n');
        }
        return 0;
    }
}
signed main(){return WSN::main();}

T3 f

沽沽沽～～～