[HDU多校02] HDU 6315 Naive Operations 线段树

最新推荐文章于 2019-02-13 00:04:44 发布

Uniontake

最新推荐文章于 2019-02-13 00:04:44 发布

阅读量138

点赞数

分类专栏：线段树

本文链接：https://blog.csdn.net/m0_38013346/article/details/81227031

版权

线段树专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Naive Operations

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 502768/502768 K (Java/Others)
Total Submission(s): 1720 Accepted Submission(s): 738

Problem Description

In a galaxy far, far away, there are two integer sequence a and b of length n.
b is a static permutation of 1 to n. Initially a is filled with zeroes.
There are two kind of operations:
1. add l r: add one for al,al+1...ar
2. query l r: query ∑ri=l⌊ai/bi⌋

Input

There are multiple test cases, please read till the end of input file.
For each test case, in the first line, two integers n,q, representing the length of a,b and the number of queries.
In the second line, n integers separated by spaces, representing permutation b.
In the following q lines, each line is either in the form 'add l r' or 'query l r', representing an operation.
1≤n,q≤100000, 1≤l≤r≤n, there're no more than 5 test cases.

Output

Output the answer for each 'query', each one line.

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

Source

2018 Multi-University Training Contest 2

题意

给出两个n个元素的数组A,B;

A数组初始值为0，B数组输入。

现在要求完成以下两种操作

1.add l r 将 A数组[l,r]区间加1

2.query l r 计算 $\sum_{i=l}^{r} \left \lfloor \frac{A[i]}{B[i]} \right \rfloor$

题解

我们会想这就是一个线段树的题目，可是由于query运算中的下取整导致运算不具有可加性。

也就是说单纯的区间更新区间查询并不能维护这样的运算。

所以我们无法实现完美的区间更新。

但是我们发现区间更新只有很小一部分才会对答案 $\sum_{i=l}^{r} \left \lfloor \frac{A[i]}{B[i]} \right \rfloor$ 产生贡献，更一般的来说就是我们允许将一部分区间更新

变为单点更新。

那么我们来考虑一下什么时候需要单点更新，

设 $C[i] = \left \lfloor \frac{A[i]}{B[i]} \right \rfloor$ ，每次查询[l,r]就变成 $\sum_{i=l}^{r}C[i]$

而 $C[i]$ 被更新的时候当且仅当A[i] == k*B[i]， $C[i]$ 需要更新意味着需要单点更新，即更新到线段树叶节点。

而A[i]从0开始每次加1，Q查询次数最多为100000

所以C[i]总共被更新 $\sum_{i=1}^{n}\frac{q}{B[i]} = q*\sum_{i=1}^{n}\frac{1}{B[i]} = O(qlogn)$

而q和n最大为100000，O(qlogn)还是可行的

具体做法就是

线段树维护两个数组minv[],sum[]

minv维护区间最小值，sum维护答案 $C[i]$ 的区间和。

minv数组初始化为B[]数组的值，每次add操作相当于区间减法。

当minv[rt] 为1时，表示这个区间存在对C[](sum[])产生贡献的元素。

于是需要更新到叶子节点。

其余只需要区间更新即可。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
int b[maxn],n,q,ql,qr;
char op[10];
struct SegTree 
{
    int sum[maxn<<2],minv[maxn<<2],lz[maxn<<2];
    void init() {
        memset(minv,0,sizeof(minv));
        memset(sum,0,sizeof(sum));
        memset(lz,0,sizeof(lz));
    }
    void push_up(int rt) {
        minv[rt] = min(minv[rt<<1],minv[rt<<1|1]); 
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];
    }
    void push_down(int rt) {
        if(!lz[rt]) return;
        lz[rt<<1] += lz[rt];
        lz[rt<<1|1] += lz[rt];
        minv[rt<<1] += lz[rt];
        minv[rt<<1|1] += lz[rt];
        lz[rt] = 0;
    }
    void build(int arr[],int l,int r,int rt) {
        lz[rt] = minv[rt] = sum[rt] = 0;
        if(l == r) {
            minv[rt] = arr[l];
            return;
        }
        int mid = (l+r)>>1;
        build(arr,l,mid,rt<<1);
        build(arr,mid+1,r,rt<<1|1);
        push_up(rt);
    }
    void update(int ql,int qr,int l,int r,int rt) {
        if(ql == l && qr == r) {
            if(minv[rt] > 1) {
                minv[rt]--;
                lz[rt]--;
            }
            else {
                if(ql == qr) {
                    sum[rt]++;
                    minv[rt] = b[l];
                }
                else {
                    push_down(rt);
                    int mid = (l+r)>>1;
                    if(minv[rt<<1] == 1) update(ql,mid,l,mid,rt<<1);
                    else {
                        minv[rt<<1]--;
                        lz[rt<<1]--;
                    }
                    if(minv[rt<<1|1] == 1) update(mid+1,qr,mid+1,r,rt<<1|1);
                    else {
                        minv[rt<<1|1]--;
                        lz[rt<<1|1]--;
                    }
                    push_up(rt);
                }
            }
            return;
        }
        push_down(rt);
        int mid = (l + r) >> 1;
        if(qr <= mid) update(ql,qr,l,mid,rt<<1);
        else if(ql > mid) update(ql,qr,mid+1,r,rt<<1|1);
        else {
            update(ql,mid,l,mid,rt<<1);
            update(mid+1,qr,mid+1,r,rt<<1|1);
        }
        push_up(rt);
    }
    int query(int ql,int qr,int l,int r,int rt) {
        if(ql == l && qr == r) {
            return sum[rt];
        }
        push_down(rt);
        int mid = (l+r)>>1;
        if(qr <= mid) return query(ql,qr,l,mid,rt<<1);
        if(ql > mid) return query(ql,qr,mid+1,r,rt<<1|1);
        return query(ql,mid,l,mid,rt<<1) + query(mid+1,qr,mid+1,r,rt<<1|1);
    }

}seg;
int main()
{
    while(~scanf("%d%d",&n,&q))
    {
        for(int i=1;i<=n;i++) scanf("%d",&b[i]);
        seg.init();
        seg.build(b,1,n,1);
        while(q--)
        {
            scanf("%s%d%d",op,&ql,&qr);
            if(op[0] == 'a') {
                seg.update(ql,qr,1,n,1);
            }
            else {
                printf("%d\n",seg.query(ql,qr,1,n,1));
            }
        }
    }  
    return 0; 
}