Naive Operations HDU多校（线段树上线段果)

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

1
1
2
4
4
6

 

这题写不出的我不敢说话，

线段树上线段果，线段树上你和我！

我都要自挂线段树了

 求query ∑ri=l⌊ai/bi⌋ 

  这个就要转化一下模型

以为向下取整 所以一开始ai=0  

所以可以每次add操作就相当于bi--

当bi等于0的时候 sum++；然后bi变回最开始的值

构造一个线段树维护区间最小值和sum

 

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int maxn = 1e5 + ;
 int n,m,a[maxn];
 struct node {
     LL val, key, lazy, sum;
 } tree[maxn << ];
 void pushup(int rt) {
     tree[rt].sum = tree[rt << ].sum + tree[rt <<  | ].sum;
     tree[rt].val = min(tree[rt << ].val, tree[rt <<  | ].val);
 }
 void pushdown(int rt) {
     tree[rt << ].lazy += tree[rt].lazy;
     tree[rt <<  | ].lazy += tree[rt].lazy;
     tree[rt << ].val -= tree[rt].lazy;
     tree[rt <<  | ].val -= tree[rt].lazy;
     tree[rt].lazy = ;
 }
 void build(int l, int r, int rt) {
     tree[rt].lazy = tree[rt].sum = ;
     if (l == r) {
         tree[rt].key = tree[rt].val = a[l];
         return ;
     }
     int m = (l + r) >> ;
     build(l, m, rt << );
     build(m + , r, rt <<  | );
     pushup(rt);
 }
 void update(int L, int R, int l, int r, int rt) {
     if(l > r) return ;
     if (tree[rt].val >  && l == L && r == R) {
         tree[rt].val--;
         tree[rt].lazy++;
         return ;
     }
     if (tree[rt].val ==  && l == r) {
         tree[rt].sum++;
         tree[rt].val = tree[rt].key;
         tree[rt].lazy = ;
         return ;
     }
     if (tree[rt].lazy > ) pushdown(rt);
     int m = (l + r) >> ;
     if (R <= m) update(L, R, l, m, rt << );
     else if (L > m) update(L, R, m + , r, rt <<  | );
     else {
         update(L, m, l, m, rt << );
         update(m + , R, m + , r, rt <<  | );
     }
     pushup(rt);
 }
 LL query(int L, int R, int l, int r, int rt) {
     if(l > r) return ;
     if (l == L && r == R) return tree[rt].sum;
     int m = (l + r) >> ;
     if (R <= m) return query(L, R, l, m, rt << );
     else if (L > m) return query(L, R, m + , r, rt <<  | );
     else return query(L, m, l, m, rt << ) + query(m + , R, m + , r, rt <<  | );
 }
 int main() {
     while(scanf("%d%d", &n, &m) != EOF) {
         for (int i =  ; i <= n ; i++ ) scanf("%d", &a[i]);
         build(, n, );
         char str[];
         int x, y;
         while(m--) {
             scanf("%s%d%d", str, &x, &y);
             if (str[] == 'a')  update(x, y, , n, );
             else printf("%lld\n", query(x, y, , n, ));
         }
     }
     return ;
 }