POJ 3468 A Simple Problem with Integers 树状数组 区间修改 区间查询

题目链接点这儿

给你一个数列，最多10W次操作，要么区间统一加上某个值，要么查询某个区间的和。

第一反应肯定是线段树，但是呢，这个能不能用树状数组做呢？

如果是单点修改，区间查询，我们直接在原数列上进行树状数组的操作。

如果是区间修改，单点查询。由于树状数组每次update一个单点x之后，会对n>x的getsum(n)（或者说树状数组的Query(n)操作）都有影响。也就是说，虽然修改的是单点，但对查询的影响是区间的。从而我们可以利用这个，在保持原数列不改变的同时另找一个树状数组来记录每个位置修改的值。如果在区间[i, j]每个值增加delta，那么我们可以通过update(i, delta), update(j+1, -delta)的操作来使getsum(pos)的值就是pos这个位置到这一时刻位置为止的改变量。从而查询i处的值的话，只需返回a[i] + getsum(i)（a[i]是该位置的初始值）。

那么现在要区间查询，仍然可以借助区间修改，单点查询的思路，但是我们还要求Σgetsum(i)(i >= left value, i <= right value)，这个操作直接写明显会浪费很大力气。

我们记树状数组维护的那个数组为b[]（也就是说这个数组满足为点k处的修改值）

我们现在要求的是，经过转换后有，那么在转换一下的话，我们就有了。那么到了这一步之后，我们可以发现，前两项都是一个树状数组的Query操作，而最后一项也可以表示成另一个树状数组i*bi的两次Query操作之差。从而我们找到了用树状数组模拟线段树区间操作的方法。

下面放出代码

[cpp] view plaincopyprint?

1. #include <vector>  
2. #include <list>  
3. #include <map>  
4. #include <set>  
5. #include <deque>  
6. #include <queue>  
7. #include <stack>  
8. #include <bitset>  
9. #include <algorithm>  
10. #include <functional>  
11. #include <numeric>  
12. #include <utility>  
13. #include <sstream>  
14. #include <iostream>  
15. #include <iomanip>  
16. #include <cstdio>  
17. #include <cmath>  
18. #include <cstdlib>  
19. #include <cctype>  
20. #include <string>  
21. #include <cstring>  
22. #include <cstdio>  
23. #include <cmath>  
24. #include <cstdlib>  
25. #include <ctime>  
26. #include <climits>  
27.   
28. #define up(i, lower, upper) for(int i = lower; i < upper; i++)  
29. #define down(i, lower, upper) for(int i = upper-1; i >= lower; i--)  
30.   
31. using namespace std;  
32.   
33. #define MAX_N 100010  
34. typedef pair<int, int> pii;  
35. typedef pair<double, double> pdd;  
36. typedef vector<int> vi;  
37. typedef vector<pii> vpii;  
38. typedef long long ll;  
39. typedef unsigned long long ull;  
40.   
41. const double pi = acos(-1.0);  
42. const double eps = 1.0e-9;  
43.   
44. template<class T>  
45.   
46. inline bool read(T &n){  
47.     T x = 0, tmp = 1; char c = getchar();  
48.     while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();  
49.     if(c == EOF) return false;  
50.     if(c == '-') c = getchar(), tmp = -1;  
51.     while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();  
52.     n = x*tmp;  
53.     return true;  
54. }  
55.   
56. template <class T>  
57. inline void write(T n) {  
58.     if(n < 0) {  
59.         putchar('-');  
60.         n = -n;  
61.     }  
62.     int len = 0,data[20];  
63.     while(n) {  
64.         data[len++] = n%10;  
65.         n /= 10;  
66.     }  
67.     if(!len) data[len++] = 0;  
68.     while(len--) putchar(data[len]+48);  
69. }  
70.   
71. struct BIT {  
72.     ll sum[MAX_N];  
73.     int len;  
74.   
75.     BIT() {  
76.         len = 0;  
77.         memset(sum, 0, sizeof sum);  
78.     }  
79.   
80.     BIT(int len) : len(len) {  
81.         memset(sum, 0, sizeof sum);  
82.     }  
83.   
84.     ll lowbit(ll x) { return x&(-x); }  
85.   
86.     ll getsum(int n) {  
87.         ll ans = 0;  
88.         while(n > 0) ans+=sum[n], n-=lowbit(n);  
89.         return ans;  
90.     }  
91.   
92.     void update(int pos, ll val) {  
93.         while(pos <= len) sum[pos] += val, pos+=lowbit(pos);  
94.     }  
95. };  
96. //-------------------------------------------------------  
97.   
98. BIT a, b;  
99.   
100. int main() {  
101.     int n, m, l, r, val;  
102.     ll sum[100010] = { 0 };  
103.     char str[2];  
104.     read(n), read(m);  
105.     a.len = b.len = n;  
106.     up(i, 1, n+1) read(val), sum[i] = sum[i-1] + val;  
107.     up(i, 0, m) {  
108.         scanf("%s", str);  
109.         if(str[0] == 'C') {  
110.             read(l), read(r), read(val);  
111.             a.update(l, val), a.update(r+1, -val);  
112.             b.update(l, val*l), b.update(r+1, -val*(r+1));  
113.         }  
114.         else {  
115.             read(l), read(r);  
116.             //printf("%lld", sum[r] - sum[l-1] + a.getsum(r)*(r+1) - a.getsum(l-1)*l - b.getsum(r) + b.getsum(l-1));  
117.             write(sum[r] - sum[l-1] + a.getsum(r)*(r+1) - a.getsum(l-1)*l - b.getsum(r) + b.getsum(l-1));  
118.             puts("");  
119.         }  
120.     }  
121.     return 0;  
122. }