线段树与树状数组总结分析（可能是最终版）
总算是把线段树和树状数组的例题给干完了，晚上思考下该继续做练习还是干别的专题，目前想法是干别的专题，只要每天重新做几道例题，反复做到滚瓜烂熟，遇到时能举一反一就好了。
线段树
1.批量等值修改
前提条件
是要区间修改，区间查询，且修改操作修改的值是相同的，比如批量+1，批量-1.
有一种特例是批量替换，
情景
一般是要对一个数组执行k次操作，每次改变其中一个区间内所有元素的值，然后询问一个区间内所有元素的最值或总和，
例题1区间等值操作
题解代码
void Pushdown(int k){ //更新子树的lazy值，这里是RMQ的函数，要实现区间和等则需要修改函数内容
if(lazy[k]){ //如果有lazy标记
lazy[k<<1] += lazy[k]; //更新左子树的lazy值
lazy[k<<1|1] += lazy[k]; //更新右子树的lazy值
t[k<<1] += lazy[k]; //左子树的最值加上lazy值
t[k<<1|1] += lazy[k]; //右子树的最值加上lazy值
lazy[k] = 0; //lazy值归0
}
}
注意懒标记中储存区间修改的值与长度的乘积，大概率开long long
struct node {
int l, r;
ll val;
ll lazy;
}t[N << 2];
void pushdown(node& op, ll lazy) {
op.val += lazy * (op.r - op.l + 1);
op.lazy += lazy;
}
void pushdown(int x) {
if (!t[x].lazy) return;
pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = 0;
}
void build(int l, int r, int x = 1\没有值传入时，默认初始化为1) {
t[x] = { l, r, w[l], 0 };
if (l == r) return;
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void modify(int l, int r, int c, int x = 1) {
if (l <= tr[x].l && r >= tr[x].r) { pushdown(tr[x], c); return; }\通过打标记的方法来赋值
pushdown(x);
操作时遇到了懒标记就处理下（懒的思想，顺路就搞下，不顺路就拖着不干）
int mid = tr[x].l + tr[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);\modify的递归也变成了和线段树单点修改query里的递归形式，有交集就递归。
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
ll ask(int l, int r, int x = 1) {
if (l <= t[x].l && r >= tr[x].r) return tr[x].val;
pushdown(x);
//query的唯一变化就是加上了一个pushdown();
int mid = tr[x].l + tr[x].r >> 1;
ll res = 0;
if (l <= mid) res += ask(l, r, x << 1);
if (r > mid) res += ask(l, r, x << 1 | 1);
return res;
}
int main()
{
int n, m; cin >> n >> m;
rep(i, n) scanf("%d", &w[i]);
build(1, n);
while (m--) {
char op[2]; int l, r; scanf("%s %d %d", op, &l, &r);
if (*op == 'Q') printf("%lld\n", ask(l, r));
else {
int c; scanf("%d", &c);
modify(l, r, c);
}
}
return 0;
}
自己写的acwing式代码
#include 注意：
线段树的初始化在build里完成，多组数据集时不需要再额外初始化。
例题2线段树区间覆盖，二分查找
区别似乎可以用储存的是什么，还有操作是什么来区分
题解代码
#include 经过模仿得到的acwing代码
#include 例题3最大连续区间的维护，给连续区间长度，找端点
与例题2的区别，
此题要求在一个连续的区间上操作，所以是要知道一段区间是否连续，是否足够长，
用节点信息fmax，lmax，rmax来维护区间最大连续，左到右的最大连续，右到左的最大连续
情景：
如果这段时间空闲就安排活动。
因为要找到最左的区间，用深度优先搜索来找。
递归方面倒是和例题2很像，都是有一个左侧空瓶优先。但不会例题2递归做法，还不太懂。
套路
区间合并
前提条件：找连续区间
情景
区间合并，最大连续的情景
每组i向柜台的麋鹿Canmuu申请一组Di连续的房间。
任意两个相邻村庄之间可以通过地道保持连通。八路军司令询问从第 x 个村庄可以到达多少个地道完好的村庄（包括第 x 个村庄本身）。
就是找一段最靠前的符合要求的连续空间分配给每个请求，
应对：
用fmax，lmax，和rmax来维护最大连续。
查询区间，端点如果有优先级
递归优先的情景Canmuu总是选择尽可能小的r值。
就是找一段最靠前的符合要求的连续空间分配给每个请求，
dfs深搜递归查询，有先的放在前面。
一个染色优先度的套路，
前提条件
分色1，和色2，两种颜色
色1优先级高，可以无视色2进行区间染色，优先染无色区间，次优先染色2区间，不能染色1区间
色2不能在色1染色过的地方染色。
情景：
如果没有找到，小明就冒着木叽叽的风险无视所有屌丝基友的约定，
女神时间安排操作优先于屌丝。
处理方法
用两颗树来维护女神和屌丝的时间。女神邀约时先在屌丝树上找空闲（满足条件的最大连续）找不到再在女神树上找空闲（满足条件的最大连续）
女神操作染色时，要在两棵树上都进行染色，而屌丝操作只染一棵树。
题解代码
#include 经过模仿得到的acwing代码
#include 套路
前提条件
给连续区间长度，求满足长度要求的连续区间端点。
######应对：
dfs，fmax，lmax，rmax，搜fmax，rmax+lmax，
int findleft(node tr[],int u,int v){
if(tr[u].l == tr[u].r ) return tr[u].l;
pushdown(tr,u);
if(tr[u<<1].fmax >= v)return findleft(tr,u<<1,v);
会递到第一个左子节点<v的位置，然后回归到最后一个左子节点<= v的位置，然后往下面的语句走。
if(tr[u<<1].rmax +tr[u<<1|1].lmax >= v) return tr[u<<1].r - tr[u<<1].rmax + 1;
中间的区间不符合要求，说明答案不在左子节点，就往右子节点递归。
return findleft(tr,u<<1|1,v);
}
例题4最大连通区间维护，给点找连续区间长度
找连续区间，用递归找，x点在的连续区间，长度大于n的连续区间。
没有优先级，可以先找左子节点，也可以先找右子节点。
和例题3的递归一样，x在左右子节点的合并区间或在叶子节点才返回具体的值。
fmax不能用来确定x的位置，所以没有任何用，此题就没有使用fmax，只使用了
lmax和rmax
套路：
前提条件：给点，找连续区间长度
应对，根据点与mid的值来确定在左右子节点，然后找
左rmax的左端点，
右lmax的右端点
看x在不在。在则返回左rmax+右lmax，
不在则继续搜左子节点（右子节点）
搜到叶子返回节点的lmax或rmax
int query(int u,int x){
if(tr[u].l == tr[u].r) return tr[u].lmax;
int mid = tr[u].l + tr[u].r >> 1;
if(x <= mid){
if(x>= tr[u<<1].r - tr[u<<1].rmax + 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
return query(u<<1,x);
}
else{
if(x<= tr[u<<1|1].l + tr[u<<1|1].lmax - 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
return query(u<<1|1,x);
}
}
题解代码
#include 模仿后得到的acwing代码
#include 习题1最大连续区间维护，例题3的简化版：
题链：
Hotel
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
代码
#include 习题2批量替换，例题1的变式
就只是根据操作变了个pushdown。
根节点tr[1].sum,查询树的总和
代码
#include 2.批量自适应修改
题链
Q - Hotel
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
卡壳点:
忘记build，递归的 tr[u].l == tr[u].r == 写成 =
区间修改，题目给的时l和len，以为是l和r导致错误
用l和len表示r错误，写成了l + len，应该是l + len -1 ；
代码
#include 前提条件
是区间修改，区间查询，且修改操作的修改的值是根据具体节点储存的值而变化的，比如开根，幂，替换，乘除；
新做的题里发现替换可以直接批量赋值来实现，属于等值修改。
情景
对一个序列里的元素执行k次自适应操作，每次操作一个区间，然后询问区间内所有元素的值。
也有询问某个区间内所有值经过某种处理后的值。（此种问法是询问时用一个变量储存找到的值，经过处理后返回
例题1单种操作
Can you answer these queries?
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
主要就是把modify的递归条件改成了和传统query操作相同的有交集
复杂度比较高，需要一些剪枝
代码
#include 例题2多种操作
Transformation HDU - 4578
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
题解代码
Transformation HDU - 4578 （线段树，审题很重要）_Soar-的博客-CSDN博客
#include经过模仿后得到的acwing版代码
#include 注意
注意点就是非数组模拟节点的代码要用build初始化，然后叶子节点懒标记初始化为1，因为代表的含义是两个子节点值是否相等
懒标记区间自适应修改至少耗时2s，如果能操作简单，能用简单的语句来确定是否可以省略操作（如例题1tr[u].r - tr[u].l + 1) == tr[u].sum)判断区间内是否全为1而可以省略掉区间开方操作。
其他套路：
涉及到一个多组输入的套路
前提条件是没有明确组数，结束关键词的多组数据集输入
取反while（~scanf(“%d”,&n)
和while(scanf(“%d”,&n) != EOF)
还有while（cin >> n)三种形式
习题1开方单点剪枝1e5 + 2e5，常数n为6以内：
题链
花神游历各国
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
比较
与例题1是同一题型，但例题1的题解里没有用到fmax来维护区间最大值，而是直接用
tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等来判断是否return。
例题1的做法仅限于元素最小是1的情况下，
习题1的元素最小为0，所以不能用这种做法。
于是归结出第一个剪枝套路
卡壳点：
没注意node内的maxn也要在modify内开方。
注意操作时除了l，r之外的属性基本都要处理
build初始化，注意叶子节点和根节点的初始化可能会不同。
代码
#include 套路：
区间单点修改开平方剪枝：
前提条件，
对区间进行开平方，并需要动态维护区间和：
应对
节点中用fmax维护区间最值，modify时区间最值<=1就直接return。
如果节点值最小是1的话，直接通过判断tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等可以确定是否需要剪枝。（区间值全为1）
3.区间染色
普通例题
题链
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
疑问
染过色后lazy被pushdown下移会不会有影响？
：modify经过lazy所在节点时，也就是lazy底下有节点被另外染色了此时lazy下移，这个节点没资格再代表其下的所有节点了。
判断是否颜色相同可以用个pushup，见批量自适应修改里的例题2多种操作里的pushup，但没什么必要。
代码
统计颜色种类及段数。
卡壳点：segment fault
用N作为下标访问元素时要养成写N-1的习惯，防止出现数组越界
#include 离散化例题
套路：
lazy代替sum：
区间染色
前提条件：
题目不需要求区间长度，操作时各种值无优先级，在区间上互相进行区间覆盖操作，求最后的状态。
情景
操作之间存在覆盖，遮挡的影响
之前画的一些线段可能会被后面的一些线段所覆盖
给出每张海报所贴的范围li，ri（1<=li<=ri<=10000000) 。求出最后还能看见多少张海报。
例题2离散化，下标很大，值很小
我们看这组数据[1,10],[1,3],[6,10],很明显答案是3
但是离散化之后为[1,4],[1,2],[3,4],答案变成了2
为解决这种问题,我们可以在更新线段树的时候将区间从[l,r]变成[l,r-1],就将区间转化成了[1,3],[1,1],[3,3]这样的树
但是当我们遇到这样的数据[1,3],[1,1],[2,2],[3,3],就会导致区间更新时出错,我们可以将初始数据的r都加上1,就排除了li和ri相等的情况,如果没有这种情况,离散化后的区间也都是一样的
其实这道题数据很弱,不管这样的情况也能过(逃
正解https://www.luogu.com.cn/paste/vl2ora2z
卡壳点：
query return时，+号写成，
u<<1|1,写错成u<<1
modify部分
下标用错，用了1，n
modify的值写成了1，应该是有多个值，每张海报的值不一样。
build的时候由于v的下标0的值是无意义的边界，所以build的r要写成v.size()-1;
题解代码
#include 经过模仿得到的acwing代码
#include 套路：
区间染色query查询：
前提：
区间染色问题的query
应对
如果是查颜色种类的话：
int query(int u){
if(tr[u].lazy){
if(st[tr[u].lazy]) return 0;
return st[tr[u].lazy] = 1;
}
if(tr[u].l == tr[u].r ) return 0;
return query(u<<1) + query(u<<1|1);
}
如果是查不同颜色和颜色对应的段数：
用cnt数组维护
int cnt[N];
int last = 0;
void query(int u){
if(last != tr[u].lazy) cnt[tr[u].lazy]++;
if(tr[u].lazy || tr[u].l == tr[u].r) {
last = tr[u].lazy;
return 0;
}
// 有标记直接进上面的语句了，不需要pushdown
query(u<<1),query(u<<1|1);
}
区间染色的l，r离散化
前提：l，r的值特别大以至于没法开出对应的树
应对：
vector<int> v;vector<PII > area;
开两个vector，一个离散化处理，一个存原始
int find(int u){return lower_bound(v.begin(),v.end(),u) - v.begin();}
二分查找函数，找到第一个大于等于u的元素，原始l，r可以通过这个find函数映射为离散l，r
v.clear(),area.clear();
v.push_back(-0x3f3f3f3f);
让v下标改为1至n
for(int i = 1;i <= n;i++){
int l,r;
scanf("%d%d",&l,&r);
r++;
v.push_back(l),v.push_back(r);
area.push_back(make_pair(l,r));
}
读入信息，线段树区间染色离散化的r要先++，操作时再-1抵消影响
sort(v.begin(),v.end());v.erase(unique(v.begin(),v.end()),v.end());
for(int i = 1;i <= n;i++) if(v[i] - v[i-1] != 1) v.push_back(v[i]-1);
sort(v.begin(),v.end());
离散化操作
for(int i = 0;i < n;i++){
int l = find(area[i].first),r = find(area[i].second);
modify(1,l,r-1,i+1);
}
操作时通过下标0到n-1拿出存原始l，r的vector里的元素
然后经过find映射成离散化l，r
modify操作时r-1
区别
区间等值修改里，
lazy存的是子树中所有节点要修改的值或要修改成的值，根据题意决定初始化的值，如例题1中批量+v操作，初始化为0，例题2批量替换，初始化为v的定义域之外的值。
sum存的是子树所有节点sum的总和 ，一般初始化为0.
是一个修改时给节点打上lazy，遇到lazy时解开lazy的过程。
区间自适应修改里，
lazy作为一个bool变量，存的是当前节点是否能代表子树接受修改，根据题意决定初始化的值
sum只有在lazy为1时有实际意义，
存的是这颗所有节点的值都相同的子树里的这个相同的值
修改值时，直接修改节点的值
树状数组
lowbit证明
树状数组详解 - Xenny - 博客园 (cnblogs.com)
单点修改
例题1求区间内操作数量
题链
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
卡壳点：
看了半天，原来不是求区间前缀和，而是求区间内进行了多少次操作……
怪不得题解看着很怪
套路：
前提：
取区间内操作数量
情景：
学校决定在某个时刻在某一段种上一种树，保证任一时刻不会出现两段相同种类的树，现有两种操作：
- K=1，读入 l,r 表示在 l 到 r 之间种上一种树，每次操作种的树的种类都不同；
- K=2，读入 l,r 表示询问 l 到 r 之间有多少种树。
应对：
用一个括号序列的思路来求解
比线段树更优，更简单，所以不用线段树。
![[Pasted image 20230413173234.png]]
统计10之前有多少个左括号，再统计3之前以后多少个右括号，3之前的右括号肯定可以和10里面的某些左括号(匹配，且在3之前，说明这对括号对应的操作没有覆盖3到10
所以覆盖了3到10的括号就是10之前有多少个左括号减去3之前的右括号
用两个树状数组，一个维护左括号，一个维护右括号，单点修改就行了。
代码
#include 例题2树状数组模拟哈希
题链
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
卡壳点：
树状数组套路不熟悉，query里res没有初始化为0
没有看出来是树状数组模拟哈希，套路不熟悉。
没有注意到没有给出操作数量的范围，没开long long导致wa。
同类题目
( 树状数组哈希前缀和）小朋友排队
AcWing 1215. 小朋友排队 - AcWing
[AcWing 1215. 小朋友排队 - AcWing](https://www.acwing.com/activity/content/problem/content/1722/)
#### 我的思路（疯狂踩陷阱）
// 1e5,1e6
// ，表示小朋友的不高兴程度和的最小值。
// 开始的时候，所有小朋友的不高兴程度都是 0
// 。
// 如果某个小朋友第一次被要求交换，则他的不高兴程度增加 1
// ，如果第二次要求他交换，则他的不高兴程度增加 2
// （即不高兴程度为 3
// ），依次类推。当要求某个小朋友第 k
// 次交换时，他的不高兴程度增加 k
// 。
// n = (1 + cnt)*cnt / 2;
**// 相邻交换的最优解是冒泡排序，要求排序次数**
// 每次交换，一个数前面比他大的数量-1，或在后面比他小的数-1，所以交换次数就是在前面且> x，在后面且< x的数字数量，**哈希后求前缀和**可以实现这个操作，**动态求前缀和适合用树状数组，用树状数组模拟hash求前缀和后缀和**，然后等查数列求和求每一项
***
#### 题解思路
// 先前总结过一个 求数组中有多少个数小于等于的套路
// 变化一下，
// 求数组中前面有多少个数小于等于x，只要遍历数组，边哈希边前缀和（l-1，x）
// 求数组中后面有多少个数小于等于x，只要逆序遍历数组，边哈希边前缀和（l-1，x）
// 求数组中前面有多少个数大于等于x，只要遍历数组，边哈希边前缀和（x-1，r）
// 求数组中后面有多少个数大于等于x，只要逆序遍历数组，边哈希边前缀和（x-1，r）
// 单纯小于或大于x，则x变为x-1或x+1,
// 检查数据范围时要把计算式全部看一遍，看看会不会爆范围。
***// 检查数据范围时看到数据包含0或负数，取模时要打起十二分精神，看看有没有踩到陷阱***
***
### 套路：
哈希前缀和
前提条件
序列，元素关系。序列中大于x的数量，小于x的数量，或是前面大于x的数量，后面大于x的元素数量
应对
要一个哈希数组，一个保存结果的数组，可能要一个原数组
求数组中前面有多少个数小于等于x，只要遍历数组，边哈希边前缀和（l-1，x）
求数组中后面有多少个数小于等于x，只要逆序遍历数组，边哈希边前缀和（l-1，x）
求数组中前面有多少个数大于等于x，只要遍历数组，边哈希边前缀和（x-1，r）
求数组中后面有多少个数大于等于x，只要逆序遍历数组，边哈希边前缀和（x-1，r）
严格小于或大于x，则x变为x-1或x+1,
发现要求前面时，顺序遍历数组，后面时，倒序遍历数组
检查数据范围时要把计算式全部看一遍，看看会不会爆数据。
如果序列元素会改变，需要动态维护序列，要用树状数组或线段树来模拟哈希
用树状数组模拟哈希的重点是
重点是要满足边哈希，边求哈希前缀和
贪心策略
前提条件
相邻交换序列元素：
应对
最优策略是冒泡排序，每个元素会被交换的次数等于
在前面且> x，在后面且< x的数字数量之和
（树状数组，线段树）（数组模拟哈希）（解题步骤）acwing数星星
https://www.acwing.com/problem/content/1267/
### 题链
https://www.acwing.com/problem/content/1267/
~~没买课的点不开，耗子尾汁~~
文末放图片
### 解决问题先看本质，找数据范围与输出
>// 输出格式
// N行，每行一个整数，分别是 0级，1级，2级，……，N−1级的星星的数目。
// 数据范围
// 1≤N≤15000
// ,
// 0≤x,y≤32000
**范围不是很特殊，没有太多信息**
### // 带着疑惑去看题干，轻松抓重点
==// 级是什么，数量如何统计：==
**在题干中发现：**
>// 如果一个星星的左下方（包含正左和正下）有 k颗星星，就说这颗星星是 k级的。
**// 因为涉及到坐标以及求和，到这里可以想到大概是用一个二维前缀和，但是二维前缀和要开的数组太大了，用不了，再看有没有其他条件，
// 结果发现还真有:**
>// **不会有星星重叠。星星按 y坐标增序给出，y坐标相同的按 x坐标增序给出。**
// 给出的点的y是不严格递增的，且y相同时，x是递增的这意味着，前面的点永远在后面的点的下方，
由此题目就变成按顺序看星星的话可以只看x坐标来判断前面的星星是否要计入后面的点的数量。
数量的计算就可以变成计算哈希统计x坐标各种情况的出现次数，然后计算1~x的前缀和。
// 因为涉及到了数组单点修改以及求和操作，所以可以用一个树状数组或线段树来模拟哈希维护数据
//观察样例发现星星计数时是不计自身的，所以先求树状数组里统计的前缀和，再修改树状数组里的值
// 统计数量级又要统计各种数量的出现情况，又要一层哈希
// 第一颗星星的左下方不可能有星星，且计数时不计自身，必然有0级的星星最后遍历哈希0到n-1
### 套路：
###### 树状数组模拟哈希
前提条件
需要动态维护序列元素大小以及前缀和。
应对：
求[l,r] 前缀和，用query(r) - query(l - 1)
###### 哈希前缀和
前提条件
序列，元素关系。序列中大于x的数量，小于x的数量，或是前面大于x的数量，后面大于x的元素数量
应对
求数组中前面有多少个数小于等于x，只要遍历数组，边哈希边前缀和（l-1，x）
求数组中后面有多少个数小于等于x，只要逆序遍历数组，边哈希边前缀和（l-1，x）
求数组中前面有多少个数大于等于x，只要遍历数组，边哈希边前缀和（x-1，r）
求数组中后面有多少个数大于等于x，只要逆序遍历数组，边哈希边前缀和（x-1，r）
严格小于或大于x，则x变为x-1或x+1,
检查数据范围时要把计算式全部看一遍，看看会不会爆数据。
如果序列元素会改变，需要动态维护序列，要用树状数组或线段树来模拟哈希
---
### 代码：
```cpp
#include
#include
#include
#include
using namespace std;
const int N = 4e4;
using namespace std;
int tr[N],w[N],f[N];
int lowbit(int x){
return x & -x;
}
void add(int x,int v){
for(int i = x;i <= N;i+=lowbit(i)) tr[i] += v;
}
int query(int x){
int res = 0;
for(int i = x;i ;i -=lowbit(i)) res += tr[i];
return res;
}
int main(){
int n;
int x,y;
cin >> n;
for(int i = 0;i < n;i++){
scanf("%d%d",&x,&y);
x++;
f[query(x)] ++;
add(x,1);
}
for(int i = 0;i < n;i++){
printf("%d\n",f[i]);
}
return 0;
}
题3树状数组区间修改，用不到，暂时不管
`则A[1]+A[2]+…+A[n]
``= (D[1]) + (D[1]+D[2]) + … + (D[1]+D[2]+…+D[n])
``= n*D[1] + (n-1)*D[2] +… +D[n]
``= n * (D[1]+D[2]+…+D[n]) - (0D[1]+1D[2]+…+(n-1)*D[n])
`1到n的前缀和等于= n * (D[1]+D[2]+…+D[n]) - (0D[1]+1D[2]+…+(n-1)*D[n])
`所以上式可以变为∑ni = 1A[i] = n∑ni = 1D[i] - ∑ni = 1( D[i](i-1) );
`所以是需要维护tr1[i] = iD[i]，tr2[i] = D[i](i-1);
1 int n,m;
2 int a[50005] = {0},c[50005]; //对应原数组和树状数组
3
4 int lowbit(int x){
5 return x&(-x);
6 }
7
8 void updata(int i,int k){ //在i位置加上k
9 while(i <= n){
10 c[i] += k;
11 i += lowbit(i);
12 }
13 }
14
15 int getsum(int i){ //求D[1 - i]的和，即A[i]值
16 int res = 0;
17 while(i > 0){
18 res += c[i];
19 i -= lowbit(i);
20 }
21 return res;
22 }
23
24 int main(){
25 cin>>n;27 for(int i = 1; i <= n; i++){
28 cin>>a[i];
29 updata(i,a[i] - a[i-1]); //输入初值的时候，也相当于更新了值
31 }
32
33 //[x,y]区间内加上k
34 updata(x,k); //A[x] - A[x-1]增加k
35 updata(y+1,-k); //A[y+1] - A[y]减少k
36
37 //查询i位置的值
38 int sum = getsum(i);
39
40 return 0;
41 }
模仿
#include