Find the remaining Array element after adding values in given ranges
Given an array A[] containing N elements and an array queries containing Q queries of type [ X, L, R ] where X is the element to be added to all the elements in the range [L, R]. After performing all Q queries keep on removing two array elements and append their sum into the array till the array size becomes 1. The task is to find this remaining array element.
Note: 1-based indexing is considered.
Example:
Input: A[] = [ 1, 4, 3, 2, 4 ], queries = [ [5, 1, 2 ], [ -5, 1, 3 ] ]
Output: 9
Explanation:
1st query: Adding 5 to the first and second element, A becomes {6, 9, 3, 2, 4}.
2nd query: Adding -5 to first, second and third element, A becomes {1, 4, -2, 2, 4}.
Operation 1: Select A1=1 and A3 = -2, remove them and
add their sum (1-2=-1) to the array, A becomes {4, 2, 4, -1}.
Operation 2: Select A2=2 and A3 = -1, remove them and
add their sum (2-1=1) to the array, A becomes {4, 4, 1}.
Operation 3: Select A1=4 and A3=1, remove them and
add their sum (4+1=5) to the array, A becomes {4, 5}.
Operation 4: Select the remaining two elements and
add their sum (4+5 = 9) to the array, A becomes {9}.
Input: A = [1, 2, 3], queries = [ [-3, 1, 3 ] ]
Output: -3
Naive Approach:
First calculate the array A for all Q queries by traversing them and adding queries[i][0] from queries[i][1]-1 to queries[i][2]-1.
Then the selection of the elements has to be random but it is important to note that any pair of elements (Ai and Aj) we remove and add its sum ( Ai + Aj ) as new element, we are confirmed to get the sum of the array A as the final remaining element due to the summation property mentioned below:
Sn (sum) = (A1 + A2) + A3 + A4 + . . . + An
Sn = (S12 + A3) + A4 + . . . + An
Sn = (S123 + A4)+ . . . + An
. . . . .
Sn = S123…n
Follow the below illustration for a better understanding
Illustration:
Consider an example A = [a1, a2, a3] and queries = [[x1, 1, 2], [x2, 1, 3]]
1st query:
Adding x1 to the first and second element,
the array A becomes [ a1 + x1, a2 + x1, a3] .
new a1 = a1 + x1
new a2 = a2 + x1
2nd query:
Adding x2 to first, second and third element,
the array A becomes [ a1 + x2, a2 + x2, a3 + x2] .
new a1 = a1 + x2
new a2 = a2 + x2
new a3 = a3 + x2
Operation 1:
Select a1 and a3, remove them and add their sum (a1 + a3) to array,
A becomes [a2, (a1 + a3)].
previous a2 become a1 and the added sum will became a2.
Operation 2:
Select a1 and a2, remove them and add their sum (a1 + a2) to array,
A becomes [a1 + a2 + a3]
Follow the steps mentioned below to implement the idea:
- Traverse for all Q queries (say i).
- Traverse from queries[i][1]-1 to queries[i][2]-1 (say j).
- Add queries[i][0] to all array elements in the range.
- After all the loops are over, Traverse the array A[] to find the sum of it and store it in result.
- Return result as the final answer.
Below is the implementation of the above approach :
C++14
#include <bits/stdc++.h>
using namespace std;
int randomize(vector< int >& A, int & N,
vector<vector< int > >& queries, int & Q)
{
int result = 0;
for ( int i = 0; i < Q; i++) {
for ( int j = queries[i][1] - 1;
j < queries[i][2]; j++)
A[j] += queries[i][0];
}
for ( int i = 0; i < N; i++)
result += A[i];
return result;
}
int main()
{
vector< int > A = { 1, 4, 3, 2, 4 };
int N = A.size();
vector<vector< int > > queries
= { { 5, 1, 2 }, { -5, 1, 3 } };
int Q = queries.size();
cout << randomize(A, N, queries, Q);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int randomize( int [] A, int N, int [][] queries,
int Q)
{
int result = 0 ;
for ( int i = 0 ; i < Q; i++) {
for ( int j = queries[i][ 1 ] - 1 ;
j < queries[i][ 2 ]; j++) {
A[j] += queries[i][ 0 ];
}
}
for ( int i = 0 ; i < N; i++) {
result += A[i];
}
return result;
}
public static void main(String[] args)
{
int [] A = { 1 , 4 , 3 , 2 , 4 };
int N = A.length;
int [][] queries = { { 5 , 1 , 2 }, { - 5 , 1 , 3 } };
int Q = queries.length;
System.out.print(randomize(A, N, queries, Q));
}
}
|
Python3
def randomize( A, N, queries, Q) :
result = 0
for i in range ( 0 , Q):
for j in range (queries[i][ 1 ] - 1 , queries[i][ 2 ], 1 ):
A[j] + = queries[i][ 0 ]
for i in range (N):
result + = A[i]
return result
if __name__ = = "__main__" :
A = [ 1 , 4 , 3 , 2 , 4 ]
N = len (A)
queries = [[ 5 , 1 , 2 ], [ - 5 , 1 , 3 ]]
Q = len (queries)
print ( randomize(A, N, queries, Q))
|
C#
using System;
class GFG {
static int randomize( int [] A, int N, int [,] queries,
int Q)
{
int result = 0;
for ( int i = 0; i < Q; i++) {
for ( int j = queries[i,1] - 1;
j < queries[i,2]; j++) {
A[j] += queries[i,0];
}
}
for ( int i = 0; i < N; i++) {
result += A[i];
}
return result;
}
public static void Main( string [] args)
{
int [] A = { 1, 4, 3, 2, 4 };
int N = A.Length;
int [,] queries = { { 5, 1, 2 }, { -5, 1, 3 } };
int Q = queries.GetLength(0);
Console.WriteLine(randomize(A, N, queries, Q));
}
}
|
Javascript
<script>
function randomize( A, N,
queries, Q)
{
let result = 0;
for (let i = 0; i < Q; i++) {
for (let j = queries[i][1] - 1;
j < queries[i][2]; j++)
A[j] += queries[i][0];
}
for (let i = 0; i < N; i++)
result += A[i];
return result;
}
let A = [ 1, 4, 3, 2, 4 ];
let N = A.length;
let queries
= [ [ 5, 1, 2 ], [ -5, 1, 3 ] ];
let Q = queries.length;
document.write(randomize(A, N, queries, Q));
</script>
|
Time Complexity: O(Q*M + N) where M is the maximum range among the queries
Auxiliary Space: O(1)
Efficient Approach: The problem can also be solved efficiently by reducing the time requirement of query updates. The idea is as follows.
If we see clearly, we can find our answer by doing things backward.
- First we add all the elements present in A into a element ans and then,
- Add the elements present in queries to the range which is provided with it, i.e., simply add the queries [i]*((L-R)+1) to ans rather than applying it to the given range [L, R].
Follow the steps given below:
- Traverse A and add all the elements present in it.
- Traverse queries and add queries[i][0] * ((queries[i][1]-queries[i][2])+1) to the sum.
- Return the sum as the required answer.
Below is the implementation of the above approach :
C++14
#include <bits/stdc++.h>
using namespace std;
int solve(vector< int >& v,
vector<vector< int > >& queries)
{
int ans = 0;
for ( int i = 0; i < v.size(); i++) {
ans += v[i];
}
for ( int i = 0; i < queries.size(); i++) {
int temp = abs (queries[i][1] - queries[i][2]) + 1;
ans += queries[i][0] * temp;
}
return ans;
}
int main()
{
vector< int > A = { 1, 4, 3, 2, 4 };
int N = A.size();
vector<vector< int > > queries
= { { 5, 1, 2 }, { -5, 1, 3 } };
cout << solve(A, queries);
return 0;
}
|
Java
import java.io.*;
class GFG {
public static int solve( int v[], int queries[][])
{
int ans = 0 ;
for ( int i = 0 ; i < v.length; i++) {
ans += v[i];
}
for ( int i = 0 ; i < queries.length; i++) {
int temp
= Math.abs(queries[i][ 1 ] - queries[i][ 2 ])
+ 1 ;
ans += queries[i][ 0 ] * temp;
}
return ans;
}
public static void main(String[] args)
{
int A[] = { 1 , 4 , 3 , 2 , 4 };
int N = A.length;
int queries[][] = { { 5 , 1 , 2 }, { - 5 , 1 , 3 } };
System.out.print(solve(A, queries));
}
}
|
Python3
def solve(v, queries):
ans = 0
for i in range ( len (v)):
ans = ans + v[i]
for i in range ( len (queries)):
temp = abs (queries[i][ 1 ] - queries[i][ 2 ]) + 1
ans = ans + (queries[i][ 0 ] * temp)
return ans
A = [ 1 , 4 , 3 , 2 , 4 ]
N = len (A)
queries = [[ 5 , 1 , 2 ],[ - 5 , 1 , 3 ]]
print (solve(A,queries))
|
C#
using System;
public class GFG {
public static int solve( int []v, int [,]queries)
{
int ans = 0;
for ( int i = 0; i < v.Length; i++) {
ans += v[i];
}
for ( int i = 0; i < queries.GetLength(0); i++) {
int temp
= Math.Abs(queries[i,1] - queries[i,2])
+ 1;
ans += queries[i,0] * temp;
}
return ans;
}
public static void Main( string [] args)
{
int []A = { 1, 4, 3, 2, 4 };
int N = A.Length;
int [,]queries = { { 5, 1, 2 }, { -5, 1, 3 } };
Console.WriteLine(solve(A, queries));
}
}
|
Javascript
<script>
function solve(v, queries)
{
let ans = 0;
for (let i = 0; i < v.length; i++) {
ans += v[i];
}
for (let i = 0; i < queries.length; i++) {
let temp
= Math.abs(queries[i][1] - queries[i][2])
+ 1;
ans += queries[i][0] * temp;
}
return ans;
}
let A = [ 1, 4, 3, 2, 4 ];
let N = A.length;
let queries = [[ 5, 1, 2 ], [ -5, 1, 3 ]];
document.write(solve(A, queries));
</script>
|
Time Complexity: O(N + Q)
Auxiliary Space: O(1)
Last Updated :
14 Nov, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...