HDU 6315 Naive Operations（线段树）

Description

给出排列$b$，序列$a$初始全为$0$，两个序列长度均为$n$，$q$次操作，操作有两种

$add\ l\ r:$给区间$[l,r]$的每个值都加一

$query\ l\ r:$查询$\sum\limits_{i=l}^r \lfloor\frac{a_i}{b_i}\rfloor$

Input

多组用例，每组用例首先输入两个整数$n,q$表示序列长度和查询次数，之后输入一个长度为$n$的排列$b$，最后$q$行每行一个操作

$(1\le n,m\le 10^5)$

Output

对于每个查询操作，输出查询结果

Sample Input

5 12
1 5 2 4 3
add 1 4
query 1 4
add 2 5
query 2 5
add 3 5
query 1 5
add 2 4
query 1 4
add 2 5
query 2 5
add 2 2
query 1 5

Sample Output

1
1
2
4
4
6

Solution

由于$b$是排列，每次区间加一，$a_i$最多为$q$，那么第$i$个位置对答案的贡献至多为$\lfloor\frac{q}{b_i}\rfloor$，进而答案至多$qlog_2q$

用线段树维护$b_i-a_i\%b_i$的区间最小值，每次区间加操作变成区间减一操作，当某次操作后区间最小值为$0$说明有某些位置对答案的贡献加一，递归找到这些位置然后单点修改（$0$变成$b_i$），对答案的维护用树状数组即可，时间复杂度$O(nlog^2n)$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f,maxn=100005;
int n,q,b[maxn];
struct BIT 
{
    #define lowbit(x) (x&(-x))
    int b[maxn],n;
    void init(int _n)
    {
        n=_n;
        for(int i=1;i<=n;i++)b[i]=0;
    }
    void update(int x,int v)
    {
        while(x<=n)
        {
            b[x]+=v;
            x+=lowbit(x);
        }
    }
    int query(int x)
    {
        int ans=0;
        while(x)
        {
            ans+=b[x];
            x-=lowbit(x);
        }
        return ans;
    }
}bit;
#define ls (t<<1)
#define rs ((t<<1)|1)
int Min[maxn<<2],Lazy[maxn<<2];
int push_up(int t)
{
    Min[t]=min(Min[ls],Min[rs]);
}
int push_down(int t)
{
    if(Lazy[t])
    {
        Lazy[ls]+=Lazy[t];
        Lazy[rs]+=Lazy[t];
        Min[ls]+=Lazy[t];
        Min[rs]+=Lazy[t];
        Lazy[t]=0;
    }
}
void build(int l,int r,int t)
{
    Min[t]=INF,Lazy[t]=0;
    if(l==r)
    {
        Min[t]=b[l];
        return ;
    }
    int mid=(l+r)/2;
    build(l,mid,ls);
    build(mid+1,r,rs);
    push_up(t); 
}
void update(int L,int R,int l,int r,int t)
{
    if(L<=l&&r<=R)
    {
        Min[t]--;
        Lazy[t]--;
        return ;
    }
    push_down(t);
    int mid=(l+r)/2;
    if(L<=mid)update(L,R,l,mid,ls);
    if(R>mid)update(L,R,mid+1,r,rs);
    push_up(t);
}
void modify(int x,int l,int r,int t)
{
    if(l==r)
    {
        Min[t]=b[l];
        bit.update(l,1);
        return ;
    }
    push_down(t);
    int mid=(l+r)/2;
    if(x<=mid)modify(x,l,mid,ls);
    else modify(x,mid+1,r,rs);
    push_up(t);
}
void check(int l,int r,int t)
{
    if(Min[t]==0)
    {
        if(l==r)modify(l,1,n,1);
        else
        {
            push_down(t);
            int mid=(l+r)/2;
            if(Min[ls]==0)check(l,mid,ls);
            if(Min[rs]==0)check(mid+1,r,rs);
            push_up(t);
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&q))
    {
        for(int i=1;i<=n;i++)scanf("%d",&b[i]);
        build(1,n,1);
        bit.init(n);
        while(q--)
        {
            char op[10];
            int L,R;
            scanf("%s%d%d",op,&L,&R);
            if(op[0]=='a')
            {
                update(L,R,1,n,1);
                check(1,n,1);
            }
            else printf("%d\n",bit.query(R)-bit.query(L-1));
        }
    }
    return 0;
}