HDU5737 : Differencia

注意到$b$不变,考虑用归并树来维护这个$b$序列,对于每个节点有序地维护$b$,同时在归并的时候预处理出每个元素在左右儿子里的排名。

在归并树上额外维护区间内$a\geq b$的个数以及赋值标记。

那么在区间赋值的时候,只需要在根节点的$b$数组中做一个二分,然后往下通过预处理的名次数组转移即可,标记下放时也是如此,每次转移复杂度显然是$O(1)$。

时间复杂度$O((n+m)\log n)$。

#include<cstdio>
#include<algorithm>
const int N=100010,M=262150,E=1768950;
int Case,n,m,A,B,C=~(1<<31),i,a[N],b[N],ans,c,d,x,sum;
int st[M],en[M],v[M],tag[M],pl[E],pr[E],pool[E],cur;
void build(int x,int a,int b){
  tag[x]=-1;
  if(a==b){
    st[x]=cur+1;
    pool[++cur]=::b[a];
    en[x]=cur;
    v[x]=::a[a]>=::b[a];
    return;
  }
  int mid=(a+b)>>1;
  build(x<<1,a,mid),build(x<<1|1,mid+1,b);
  v[x]=v[x<<1]+v[x<<1|1];
  int al=st[x<<1],ar=en[x<<1],bl=st[x<<1|1],br=en[x<<1|1];
  st[x]=cur+1;
  while(al<=ar&&bl<=br)pool[++cur]=pool[al]<pool[bl]?pool[al++]:pool[bl++];
  while(al<=ar)pool[++cur]=pool[al++];
  while(bl<=br)pool[++cur]=pool[bl++];
  en[x]=cur;
  al=st[x<<1],bl=st[x<<1|1];
  for(int i=st[x];i<=cur;i++){
    while(al<=ar&&pool[al]<=pool[i])al++;
    while(bl<=br&&pool[bl]<=pool[i])bl++;
    pl[i]=al-1,pr[i]=bl-1;
    if(pl[i]<st[x<<1])pl[i]=0;
    if(pr[i]<st[x<<1|1])pr[i]=0;
  }
}
inline void tag1(int x,int p){v[x]=p?p-st[x]+1:0;tag[x]=p;}
inline void pb(int x){
  if(tag[x]<0)return;
  int p=tag[x];
  tag1(x<<1,pl[p]);
  tag1(x<<1|1,pr[p]);
  tag[x]=-1;
}
void change(int x,int a,int b,int p){
  if(c<=a&&b<=d){tag1(x,p);return;}
  pb(x);
  int mid=(a+b)>>1;
  if(c<=mid)change(x<<1,a,mid,pl[p]);
  if(d>mid)change(x<<1|1,mid+1,b,pr[p]);
  v[x]=v[x<<1]+v[x<<1|1];
}
void ask(int x,int a,int b){
  if(c<=a&&b<=d){ans+=v[x];return;}
  pb(x);
  int mid=(a+b)>>1;
  if(c<=mid)ask(x<<1,a,mid);
  if(d>mid)ask(x<<1|1,mid+1,b);
  v[x]=v[x<<1]+v[x<<1|1];
}
inline int lower(int x){
  int l=st[1],r=en[1],mid,t=0;
  while(l<=r)if(pool[mid=(l+r)>>1]<=x)l=(t=mid)+1;else r=mid-1;
  return t;
}
inline int rnd(){
  A=(36969+(ans>>3))*(A&65535)+(A>>16);
  B=(18000+(ans>>3))*(B&65535)+(B>>16);
  return(C&((A<<16)+B))%1000000000;
}
int main(){
  for(scanf("%d",&Case);Case--;printf("%d\n",sum)){
    scanf("%d%d%d%d",&n,&m,&A,&B);
    for(i=1;i<=n;i++)scanf("%d",&a[i]);
    for(i=1;i<=n;i++)scanf("%d",&b[i]);
    ans=cur=sum=0;
    build(1,1,n);
    for(i=1;i<=m;i++){
      c=rnd()%n+1,d=rnd()%n+1,x=rnd()+1;
      if(c>d)std::swap(c,d);
      if((c+d+x)&1)change(1,1,n,lower(x));
      else{
        ans=0;
        ask(1,1,n);
        sum=(1LL*ans*i+sum)%1000000007;
      }
    }
  }
  return 0;
}

  

时间: 2024-11-11 04:37:29

HDU5737 : Differencia的相关文章

hdu5737

首先思考一个朴素的做法 将b[]维护成一个线段树套有序表,每次修改a[]用线段树+lazy tag 并在线段树的子区间上在有序表中二分更新这段区间中a[i]>=b[i]的值,复杂度O(nlog^2) 有没有更优的做法? 考虑在一次修改操作中,查询的数是相同的,并且b[]这个有序表始终不变 因此在生成b[]的线段树套有序表过程中(其实就是归并排序的记录) 我们维护每个数在左右子区间中名次. 这样修改的时候我们只要对b[]排好序的整体做一次二分,找到b[m]<=x<b[m+1] 把修改成x当

hdu5737(2016多校联赛第2场D)

题意:给2组数据a和b数组,每次有2种操作:(+,l,r,x)把a数组第l个到第r个元素全置为x,(?,l,r)查询[l,r]之间哪些位置满足a[i]>=b[i](i>=l && i<=r)并把这些位置的数量统计 一直想很久,没想到什么有效的方案,直到看到题解才明白过来,原来线段树套平衡树还有这种情况:里面其实不是平衡树,只是有序表. 然后这题就转换为区间查找数对应排名 由于此题不用对2个数组都修改,其中1个b树可作为固定的线段树套有序表以节省时间,另外1个表a树则单纯使

HDU 5737 Differencia set + 主席树

HDU 5737 很明显能发现数据是随机的. 我们用set去维护值一样的段, 因为随机所以set里面线段的大小减少得很快, 平均大概30个左右. 每次查询暴力处理每一段相同的在主席树上查找累加答案就可以了. 但是这个好像不是标算, 标算复杂度(n + m) * log(n) 并且数据不是随机也可以. #pragma GCC optimize(2) #pragma GCC optimize(3) #include<bits/stdc++.h> #define LL long long #defi