C++ 带点更新的范围和中的范围
我们得到了一个包含N个元素和N个范围的数组A，每个数组的形式为[L，R]。将一个范围的值称为从索引L到索引R（包括）中所有元素的总和 示例：让数组A=[2 5 7 9 8]，给定的范围为[2,4]，则该范围的值为5+7+9=21 现在，我们将为两种类型中的每种查询提供Q查询：C++ 带点更新的范围和中的范围,c++,algorithm,time-complexity,segment-tree,C++,Algorithm,Time Complexity,Segment Tree,我们得到了一个包含N个元素和N个范围的数组A，每个数组的形式为[L，R]。将一个范围的值称为从索引L到索引R（包括）中所有元素的总和 示例：让数组A=[2 5 7 9 8]，给定的范围为[2,4]，则该范围的值为5+7+9=21 现在，我们将为两种类型中的每种查询提供Q查询： 1. 0 X Y : It means change Xth element of array to Y. 2. 1 A B : It means we need to report the sum of values o
1. 0 X Y : It means change Xth element of array to Y.
2. 1 A B : It means we need to report the sum of values of ranges from A to B.
R1: [1,3] Then value corresponding to this range is 2+3+7=12
R2: [4,5] Then value corresponding to this range is 8+6=14
R3: [3,6] Then value corresponding to this range is 7+8+6+5=26
Q1: 1 1 2
Then here answer is value of Range1 + value of Range2 = 12+14=26
Q2: 0 2 5
It means Change 2nd element to 5 from 3.It will change the result of Range 1.
Now value of Range1 becomes 2+5+7=14
Q3: 1 1 2
Then here answer is value of Range1 + value of Range2 = 14+14=28
#include<bits/stdc++.h>
using namespace std;
long long arr[100002],i,n,Li[100002],Ri[100002],q,j;
long long queries[100002][2],query_val[100002],F[100002],temp;
long long ans[100002];
int main()
{
scanf("%lld",&n);
for(i=1;i<=n;i++)
scanf("%lld",&arr[i]);
for(i=1;i<=n;i++)
{
scanf("%lld%lld",&Li[i],&Ri[i]);
}
for(i=1;i<=n;i++)
{
F[n] = 0;
ans[i] = 0;
}
scanf("%lld",&q);
for(i=1;i<=q;i++)
{
scanf("%lld",&query_val[i]);
scanf("%lld%lld",&queries[i][0],&queries[i][1]);
}
for(i=1;i<=n;i++)
{
for(j=Li[i];j<=Ri[i];j++)
{
F[i] = F[i] + arr[j];
}
}
long long diff;
long long ans_count = 0,k=1;
for(i=1;i<=q;i++)
{
if(query_val[i] == 1)
{
temp = arr[queries[i][0]];
arr[queries[i][0]] = queries[i][1];
diff = arr[queries[i][0]] - temp;
for(j=1;j<=n;j++)
{
if(queries[i][0]>=Li[j] && queries[i][0]<=Ri[j])
F[j] = F[j] + diff;
++k;
}
}
else if(query_val[i] == 2)
{
++ans_count;
for(j=queries[i][0];j<=queries[i][1];j++)
ans[ans_count] = ans[ans_count] + F[j];
}
}
for(i=1;i<=ans_count;i++)
{
printf("%lld\n",ans[i]);
}
return 0;
}
#包括
使用名称空间std；
龙龙arr[100002]，i，n，Li[100002]，Ri[100002]，q，j；
长查询[100002][2]，查询值[100002]，F[100002]，温度；
龙龙安[100002]；
int main（）
{
scanf（“%lld”、&n）；
对于（i=1；i您可以使用段树
#包括
const int MAX_N=100003；
int树[（1y | | r=x&&r y|r
基本思想是将元素数组扩展为二叉树。该树的每个节点都保存有关其子节点元素总和的信息。通过应用以下技巧，您可以轻松知道某个节点覆盖的范围：
Root正在保存范围[1，N]
的信息。
根的左子级保存有关范围的信息[1，int（N/2）]
。
根的右子级包含有关范围[int（N/2）+1，N]
的信息
通常情况下，如果节点“A”包含有关范围的信息[l，r]
，则左键为子节点
保存有关范围的信息[l，int（（l+r）/2）]
并且右子级保存信息
关于范围[int（（l+r）/2）+1，r]
还有一个在数组中表示二叉树的好技巧。
假设您将树保存在数组“tree”中（当我编写代码时），然后是它的根
树将在树[1]
中。根的左子级将是树[2]
和树的右子级
根目录将成为树[3]
通常，如果您在节点n
上，则其左子节点是2*n
，右子节点是2*n+1
这就是为什么我用（1，0，N-1）调用我的查询和更新函数的原因。我从根节点1
开始。我用该节点覆盖的范围I[0，N-1]。我总是试图找到第一个节点，该节点适合我需要计算的范围之和
这是一个开始。试着在谷歌上搜索更多关于分段树的信息。当你开始探索时，你会发现有几种方法可以表示你的树
祝你好运
因此，对于第一个查询，我们必须用+26更新2-4
。我们不更新2-4之间的所有元素，而是将其存储在懒惰树中，每当我们从树中访问任何节点时，我们首先检查该节点是否有任何挂起的更新。如果没有挂起的更新，则完成并将其转移到其子节点
q1:- 0 2 4 26
tree[0,78,78,0,26,52,0,0,0,26]
尝试建立树索引；对于左树（2*i+1）
和右（2*i+1）
第一个索引至少为78，即树的顶部，因此从[0，n-1]
当前最大值为78
tree[treeNode]+=（高低+1）*惰性[treeNode]；
如果我们将x
从低索引添加到高索引，那么在整个子数组中i
添加了（高-低+1）*x；-1
，因为从0
进行索引
然后，在从树中访问任何节点之前，我们惰性地检查该节点是否有任何挂起的更新。如果（lazy[treeNode]！=0）
如果有，则更新并将lazy传输到其子节点。对左子树和右子树也继续这样做
然后我们到达范围[startR，endR]
正如我前面提到的，我们首先检查每个受影响节点的挂起更新。如果为true，则它完成该更新，并根据间隔递归调用左、右子树
最后我们得到根节点的leftSubtree
和righsubtree
之和，添加它们并返回它们
时间复杂性
在更新中，getAnswer（）
，在最坏的情况下，必须遍历整个树，即树的高度O（2*logn）
2*logn
，因为在最坏的情况下，我们必须在左右子树中移动，例如间隔[0-N-1]
对于k
查询，总体时间复杂度将是O（k*log n）
@j\u random\u hacker How？请提供一些解释，我真的无法解释它比Peter Fenwick的原始论文更好，你可以从维基百科页面上获得，这是谷歌对“Fenwick tree”的第一个结果.听起来你已经有了正确的方法
#include <iostream>
using namespace std;
typedef long long ll;
void updateSegementLazyTree(ll *tree , ll *lazy , ll low, ll high,ll startR ,ll endR ,ll updateValue ,ll treeNode)
{
//before using current node we need to check weather currentnode has any painding updation or not
if (lazy[treeNode]!=0)
{
//update painding updation
tree[treeNode] += (high-low+1)*lazy[treeNode];
//transfer update record to child of current node if child possible
if (low!=high)
{
//that's means child possible
lazy[treeNode*2] += lazy[treeNode]; //append update to left child
lazy[treeNode*2+1] += lazy[treeNode]; //append update to right child
}
lazy[treeNode]=0;//remove lazyness of current node
}
//if our current interval [low,high] is completely outside of the given Interval[startR,endR]
if (startR >high || endR <low || low>high)
{
//then we have to ignore those path of tree
return;
}
//if our current interval is completely inside of given interval
if (low >=startR && high <=endR)
{
//first need to update the current node with their painding updation
tree[treeNode] += (high-low+1)*updateValue;
if (low!=high)
{
//that's means we are at the non-leaf node
lazy[treeNode*2] +=updateValue; //so append lazyness to their left child
lazy[treeNode*2+1] +=updateValue;//append lazyness to their right child
}
return;
}
//partially inside and outside then we have to traverse all sub tree i.e. right subtree and left subtree also
ll mid=(low+high)/2;
updateSegementLazyTree(tree , lazy , low, mid, startR , endR , updateValue , treeNode*2);
updateSegementLazyTree(tree , lazy , mid+1, high, startR , endR , updateValue , treeNode*2+1);
//while poping the function from stack ,we are going to save what i have done....Ok!!!!
//update tree node:-
tree[treeNode] = tree[treeNode*2] + tree[treeNode*2+1]; //left sum+rightsum(after updation)
}
ll getAnswer(ll *tree ,ll * lazy , ll low, ll high ,ll startR,ll endR , ll treeNode)
{
//base case
if (low>high)
{
return 0;
}
//completely outside
if (low >endR || high <startR)
{
return 0;
}
//before using current node we need to check weather currentnode has any painding updation or not
if (lazy[treeNode]!=0)
{
//i.e. if we would have added x value from low to high then total changes for root node will be (high-low+1)*x
tree[treeNode] += (high-low+1)*lazy[treeNode];
if (low!=high)
{
//if we are at non-leaf node
lazy[treeNode*2] += lazy[treeNode]; //append updateion process to left tree
lazy[treeNode*2+1] += lazy[treeNode];//append updation process to right tree
}
lazy[treeNode]=0;
}
//if our current interval is completely inside of given interval
if (low >=startR && high <=endR)
{
return tree[treeNode];
}
//if our current interval is cpartially inside and partially out side of given interval then we need to travers both side left and right too
ll mid=(low+high)/2;
if(startR>mid)
{
//that's means our start is away from mid so we need to treverse in right subtree
return getAnswer( tree , lazy , mid+1, high, startR, endR , treeNode*2+1);
}else if(endR <= mid){
//that's means our end is so far to mid or equal so need to travers in left subtree
return getAnswer( tree , lazy , low, mid, startR, endR , treeNode*2);
}
ll left=getAnswer( tree , lazy , low, mid, startR, endR , treeNode*2); //traverse right
ll right=getAnswer( tree , lazy , mid+1, high, startR, endR , treeNode*2+1); //and left
return (left+right);//for any node total sum=(leftTreeSum+rightTreeSum)
}
int main()
{
int nTestCase;
cin>>nTestCase;
while(nTestCase--)
{
ll n,nQuery;
cin>>n>>nQuery;
ll *tree=new ll[3*n]();
ll *lazy=new ll[3*n]();
while(nQuery--)
{
int choice;
cin>>choice;
if (choice==0)
{
ll startR,endR,updateValue;
cin>>startR>>endR>>updateValue;
//0:- start index , n-1 end index ,1 treeIndex tree is our segment tree and lazy is our lazy segment tree
updateSegementLazyTree(tree , lazy , 0, n-1, startR-1 , endR-1 , updateValue , 1);
// for (int i = 0; i < 3*n; ++i)
// {
// cout<<i<<"\t"<<tree[i]<<"\t"<<lazy[i]<<endl;
// }
}else{
ll startR,endR;
cin>>startR>>endR;
ll answer=getAnswer(tree , lazy , 0, n-1 , startR-1 , endR-1 , 1);
cout<<answer<<endl;
}
}
}
}
1
8 6
0 2 4 26
0 4 8 80
0 4 5 20
1 8 8
0 5 7 14
1 4 8
q1:- 0 2 4 26
tree[0,78,78,0,26,52,0,0,0,26]