Range sum query

Range sum query DEFAULT

classNumArray{

public:

NumArray(vector<int>nums){

n=nums.size();

if(n==0){return;}

this->nums=nums;

segTree=constructSegTree(nums,0,n-1);

}

voidupdate(inti,intval){

updateSegTree(segTree,0,n-1,i,val);

nums[i]=val;

}

intsumRange(inti,intj){

returntreeSum(segTree,0,n-1,i,j);

}

private:

structTreeNode

{

intvalue;

TreeNode*left;

TreeNode*right;

};

TreeNode*segTree;

vector<int>nums;

intn;

TreeNode*constructSegTree(constvector<int>&nums,intst,inted){

TreeNode*tnode=newTreeNode();

if(st==ed){

tnode->value=nums[st];

}else{

intmid=st+(ed-st)/2;

tnode->left=constructSegTree(nums,st,mid);

tnode->right=constructSegTree(nums,mid+1,ed);

tnode->value=tnode->left->value+tnode->right->value;

}

returntnode;

}

inttreeSum(TreeNode*segTree,intst,inted,intl,intr){

if(st>=l&&ed<=r){

returnsegTree->value;

}elseif(ed<l||st>r){

return0;

}else{

intmid=st+(ed-st)/2;

returntreeSum(segTree->left,st,mid,l,r)+treeSum(segTree->right,mid+1,ed,l,r);

}

}

voidupdateSegTree(TreeNode*segTree,intst,inted,inti,intval){

intmid=st+(ed-st)/2;

intdiff=val-nums[i];

if(st==ed){

segTree->value+=diff;

}elseif(i<=mid){

segTree->value+=diff;

updateSegTree(segTree->left,st,mid,i,val);

}else{

segTree->value+=diff;

updateSegTree(segTree->right,mid+1,ed,i,val);

}

}

voidcheckSegTree(TreeNode*segTree){

queue<TreeNode*>q1;

queue<TreeNode*>q2;

q1.push(segTree);

while(!q1.empty()){

while(!q1.empty()){

TreeNode*tmp=q1.front();

q1.pop();

if(tmp->left){q2.push(tmp->left);}

if(tmp->right){q2.push(tmp->right);}

}

q1=q2;

q2=queue<TreeNode*>();

}

}

};

Sours: http://yucoding.blogspot.com/2017/03/leetcode-question-range-sum-query.html

Range sum queries without updates

Given an array arr of integers of size n. We need to compute the sum of elements from index i to index j. The queries consisting of i and j index values will be executed multiple times.

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input : arr[] = {1, 2, 3, 4, 5} i = 1, j = 3 i = 2, j = 4 Output : 9 12 Input : arr[] = {1, 2, 3, 4, 5} i = 0, j = 4 i = 1, j = 2 Output : 15 5

A Simple Solution is to compute the sum for every query.

An Efficient Solution is to precompute prefix sum. Let pre[i] stores sum of elements from arr[0] to arr[i]. To answer a query (i, j), we return pre[j] – pre[i-1].

Below is the implementation of the above approach:

C++

Java

Python3

 

C#

Javascript

Here time complexity of every range sum query is O(1) and the overall time complexity is O(n).

The question becomes complicated when updates are also allowed. In such situations when using advanced data structures like Segment Tree or Binary Indexed Tree.

This article is contributed by Rahul Chawla. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected] See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


My Personal Notesarrow_drop_up
Sours: https://www.geeksforgeeks.org/range-sum-queries-without-updates/
  1. Goat shopping reviews
  2. Bridezilla season 9
  3. Samsung dvi
  4. Paid search analyst jobs
  5. Minecraft building sounds

Given an integer array , handle multiple queries of the following types:

  1. Update the value of an element in .
  2. Calculate the sum of the elements of between indices and inclusive where .

Implement the class:

  • Initializes the object with the integer array .
  • Updates the value of to be .
  • Returns the sum of the elements of between indices and inclusive (i.e. ).

 

Example 1:

Input ["NumArray", "sumRange", "update", "sumRange"] [[[1, 3, 5]], [0, 2], [1, 2], [0, 2]] Output [null, 9, null, 8] Explanation NumArray numArray = new NumArray([1, 3, 5]); numArray.sumRange(0, 2); // return 1 + 3 + 5 = 9 numArray.update(1, 2); // nums = [1, 2, 5] numArray.sumRange(0, 2); // return 1 + 2 + 5 = 8

 

Constraints:

  • At most calls will be made to and .
Sours: https://leetcode.com/problems/range-sum-query-mutable/
LeetCode 303. Range Sum Query - Immutable [Algorithm + Code Explained ]

Range sum query- Immutable array

Write a service which given an integer array, returns the sum of the elements between indices i and j (i ≤ j), inclusive. Example: nums = [-2, 0, 3, -5, 2, -1]
sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

Also, the input set does not change during the calls to the sumRange(i,j).

The brute force solution is to calculate the sum of all the elements A[i] to A[j] whenever a sumRange(i,j) is called. This method has time complexity of O(n). It is OK to have this solution for small scale but as the number of queries goes up, processing of all the numbers from to would be inefficient. Also, imagine a case where the array itself is very large, then complexity for each query will lead to choking of your service.

Range sum query- Immutable array : thoughts

There are two hints for optimization is in the question, first, the array is immutable, it does not change. Second, we have to build a service, that means we have a server with us. These two things allow us to pre-compute and store results even before the query is made.

Now, the question is what do we pre-compute and how do we store it? We can precompute the sum of all the elements between each and and store them in a two-dimensional array. stores the sum of all the elements between index and . It will use additional memory, however, the response time for each sumRange query will be constant. Also, the preprocessing step is

Can we optimize for space as well? If I know the sum of all the elements from index 0 to index i and sum of all the elements from 0 to j, can I find the sum of all the elements between i and j? Of course, we can do it.

Sum(i,j) = Sum(0,j) - Sum(0,i) + A[i].

Below diagram explains it.
range sum query array

However, integer array is not passed in the query request, we cannot use it while calculating the sum. Instead, we will use formula like: Sum(i,j) = Sum(0,j) – Sum(0,i-1), which is equivalent to the above.

We will pre-calculate the sum of all the elements between index 0 and j for all j>=0 and j

Tags:arraysimmutable array range sumrange sumrange sum arrayrange sum query

Sours: https://www.algorithmsandme.com/range-sum-query-immutable-array/

Query range sum

.

Range Sum Query and Inversion Count Using BIT - Part 2

.

Similar news:

.



1785 1786 1787 1788 1789