模拟91 题解

A. Dove 打扑克

显然的结论是：超过$sqrt n$的牌堆不会超过$sqrt n$个。

所以可以分块维护信息：

对于牌数小于$sqrt n$的，用一个桶维护。

对于牌数大于$sqrt n$的，用$vector$暴力插入删除维护。

同时维护答案，为了做到$O(1)$修改，也用分块进行维护。

B. Cicada 与排序

值不同的数，位置一定是固定的。

所以可以只对值相同的数在类似归并的过程中进行$dp$。

考虑每一个值，设$dp_{i,j,dep}$表示这个值在原序列上出现的第$i$个副本，在归并排序深度为$dep$的意义下排名为$j$的概率。

处理出数组$g_{i,j}$表示归并排序过程中，两个指针分别指向$i,j$的概率，

$f_{i,j}$表示第$i$位转移到第$j$位的概率，可以在递推$g$数组的同时简单求出。

然后随便转移就完了。

C. Cicada 拿衣服

考虑题中给出的限制$min+or-max-and$。

不妨分别提出其中的$min-max,or-and$。

可以枚举当前考虑的右端点。

那么对于不同的左端点：

$or-and$只有$2*log max(a_i)$种不同的取值，

因为二进制位分别对应只增不减，只减不增。

$min-max$随着左端点不断减小单调递减。

那么可以枚举每一个不同的取值，这个可以用链表简单维护（其实用两个数组暴力重构就可以）。

二分求出符合要求的最靠左的位置就可以。

然而这样做的复杂度是$O(nlog^2n)$的，其实有一些无用的状态。

因为之要求最靠左的左端点，从左到右枚举左端点所在的区间，在第一个可行区间二分更新答案后结束枚举就完了。

为了二分时$O(1)$查询，可以使用ST表维护。

然而刚刚学到了新的数据结构猫树，而且还可以和$zkw$线段树一起用，所以打起来就很帅。

#include<iostream>
#include<cstdio>
#define lch p<<1
#define rch p<<1|1
using namespace std;
const int N=1e6+50007;
struct node{
    int pos,And,Or;
}sa[105],sb[105];
int n,k,bit,ca,cb;
int a[N],mx[22][N],mn[22][N],lg[N],ans[N<<1];
void build(int p,int l,int r,int dep){
    if(l==r) return ;
    int mid=l+r>>1;
    build(lch,l,mid,dep+1);
    build(rch,mid+1,r,dep+1);
    mx[dep][mid]=mn[dep][mid]=a[mid];
    mx[dep][mid+1]=mn[dep][mid+1]=a[mid+1];
    for(int i=mid-1;i>=l;--i) mn[dep][i]=min(mn[dep][i+1],a[i]),mx[dep][i]=max(mx[dep][i+1],a[i]);
    for(int i=mid+2;i<=r;++i) mn[dep][i]=min(mn[dep][i-1],a[i]),mx[dep][i]=max(mx[dep][i-1],a[i]);
}
void dfs(int p,int l,int r,int Ans){
    Ans=max(Ans,ans[p]);
    if(l==r){
        if(l>1&&l<=n+1) printf("%d ",Ans);
        return ;
    }
    int mid=l+r>>1;
    dfs(lch,l,mid,Ans);
    dfs(rch,mid+1,r,Ans);
}
inline int query_min(int l,int r){
    if(l==r) return a[l];
    int k=lg[bit]-lg[(l-1)^(r-1)];
    return min(mn[k][l],mn[k][r]);
}
inline int query_max(int l,int r){
    if(l==r) return a[l];
    int k=lg[bit]-lg[(l-1)^(r-1)];
    return max(mx[k][l],mx[k][r]);
}
inline void modify(int l,int r,int val){
    for(l+=bit-1,r+=bit+1;l^r^1;l>>=1,r>>=1){
        if(~l&1) ans[l^1]=max(ans[l^1],val);
        if(r&1) ans[r^1]=max(ans[r^1],val);
    }
}
inline int read(register int x=0,register char ch=getchar(),register int f=0){
    for(;!isdigit(ch);ch=getchar()) f=ch=='-';
    for(; isdigit(ch);ch=getchar()) x=(x<<1)+(x<<3)+(ch^48);
    return f?-x:x;
}
int main(){
    n=read(); k=read();
    for(int i=1;i<=n;++i) a[i]=read();
    for(bit=1;bit<=n+1;bit<<=1);
    for(int i=1;i<=bit;++i) lg[i]=lg[i>>1]+1;
    for(int i=1;i<=bit+n;++i) ans[i]=-1;
    build(1,1,bit,1);
    for(int i=1;i<=n;++i){
        for(int j=1;j<=ca;++j) sa[j].And&=a[i],sa[j].Or|=a[i];
        sa[++ca]=(node){i,a[i],a[i]}; cb=0;
        for(int j=1;j<=ca;++j) if(j==ca||sa[j].And!=sa[j+1].And||sa[j].Or!=sa[j+1].Or) sb[++cb]=sa[j];
        for(int j=1;j<=cb;++j) sa[j]=sb[j];
        ca=cb;
        int flag=0;
        for(int j=1;j<=ca&&!flag;++j)
            if(sa[j].Or-sa[j].And+query_min(sa[j].pos,i)-query_max(sa[j].pos,i)>=k){
                int l=sa[j-1].pos+1,r=sa[j].pos;
                while(l<r){
                    int mid=l+r>>1;
                    if(sa[j].Or-sa[j].And+query_min(mid,i)-query_max(mid,i)>=k) r=mid;
                    else l=mid+1;
                }
                modify(l,i,i-l+1);
                flag=1;
            }
    }
    dfs(1,1,bit,-1);
    return 0;
}