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 (A_i and A_j) we remove and add its sum ( A_i + A_j ) 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:

S_n (sum) = (A₁ + A₂) + A₃ + A₄ + . . . + A_n
S_n = (S₁₂ + A₃) + A₄ + . . . + An
S_n = (S₁₂₃ + A₄)+ . . . + A_n
         . . . . .
S_n = S_123…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

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the value of the remaining element
int randomize(vector<int>& A, int& N,
              vector<vector<int> >& queries, int& Q)
{
    int result = 0;

    // Loop to perform the queries
    for (int i = 0; i < Q; i++) {
        for (int j = queries[i][1] - 1;
             j < queries[i][2]; j++)
            A[j] += queries[i][0];
    }

    // Loop to find the sum of the array
    for (int i = 0; i < N; i++)
        result += A[i];

    return result;
}

// Driver code
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();

    // Function call
    cout << randomize(A, N, queries, Q);
    return 0;
}

Java

// Java code to implement the approach
import java.io.*;
class GFG {

  // Function to find the value of the remaining element
  static int randomize(int[] A, int N, int[][] queries,
                       int Q)
  {
    int result = 0;

    // Loop to perform the queries
    for (int i = 0; i < Q; i++) {
      for (int j = queries[i][1] - 1;
           j < queries[i][2]; j++) {
        A[j] += queries[i][0];
      }
    }

    // Loop to find the sum of the array
    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;

    // Function call
    System.out.print(randomize(A, N, queries, Q));
  }
}

// This code is contributed by lokeshmvs21.

Python3

# Python code to implement the approach

# Function to find the value of the remaining element
def randomize( A, N, queries, Q) :

    result = 0

    # Loop to perform the queries
    for i in range(0, Q):
        for j in range(queries[i][1] - 1, queries[i][2], 1):
            A[j] += queries[i][0]

    # Loop to find the sum of the array
    for i in range(N):
        result += A[i]

    return result

# Driver code
if __name__ == "__main__":

    A = [ 1, 4, 3, 2, 4 ]
    N = len(A)
    queries = [[ 5, 1, 2 ], [ -5, 1, 3  ]]
    Q = len(queries)

    # Function call
    print( randomize(A, N, queries, Q))

# This code is contributed by code_hunt.

C#

// C# code to implement the approach

using System;

class GFG {

  // Function to find the value of the remaining element
  static int randomize(int[] A, int N, int[,] queries,
                       int Q)
  {
    int result = 0;

    // Loop to perform the queries
    for (int i = 0; i < Q; i++) {
      for (int j = queries[i,1] - 1;
           j < queries[i,2]; j++) {
        A[j] += queries[i,0];
      }
    }

    // Loop to find the sum of the array
    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);

    // Function call
    Console.WriteLine(randomize(A, N, queries, Q));
  }
}

// This code is contributed by AnkThon

Javascript

<script>
// Javascriptcode to implement the approach

// Function to find the value of the remaining element
function randomize( A, N,
              queries, Q)
{
    let result = 0;

    // Loop to perform the queries
    for (let i = 0; i < Q; i++) {
        for (let j = queries[i][1] - 1;
             j < queries[i][2]; j++)
            A[j] += queries[i][0];
    }

    // Loop to find the sum of the array
    for (let i = 0; i < N; i++)
        result += A[i];

    return result;
}

// Driver code
    let A = [ 1, 4, 3, 2, 4 ];
    let N = A.length;
    let queries
        = [ [ 5, 1, 2 ], [ -5, 1, 3 ] ];
    let Q = queries.length;

    // Function call
    document.write(randomize(A, N, queries, Q));

    // This code is contributed by satwik4409.
    </script>

Output

9

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

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the remaining value
int solve(vector<int>& v,
          vector<vector<int> >& queries)
{
    int ans = 0;

    // Loop to calculate the array sum
    for (int i = 0; i < v.size(); i++) {
        ans += v[i];
    }

    // Loop to process the queries
    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;
}

// Driver code
int main()
{
    vector<int> A = { 1, 4, 3, 2, 4 };
    int N = A.size();
    vector<vector<int> > queries
        = { { 5, 1, 2 }, { -5, 1, 3 } };

    // Function call
    cout << solve(A, queries);
    return 0;
}

Java

// Java code to implement the approach
import java.io.*;

class GFG {
    // Function to find the remaining value
    public static int solve(int v[], int queries[][])
    {
        int ans = 0;

        // Loop to calculate the array sum
        for (int i = 0; i < v.length; i++) {
            ans += v[i];
        }

        // Loop to process the queries
        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;
    }

    // Driver Code
    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 } };

        // Function call
        System.out.print(solve(A, queries));
    }
}

// This code is contributed by Rohit Pradhan

Python3

# python code to implement the approach
# Function to find the remaining value
def solve(v, queries):
  ans = 0

  # Loop to calculate the array sum
  for i in range(len(v)):
    ans = ans + v[i]

  # Loop to process the queries
  for i in range(len(queries)):
    temp = abs(queries[i][1] - queries[i][2]) + 1
    ans = ans + (queries[i][0] * temp)
  return ans

# Driver code
A = [1, 4, 3, 2, 4]
N = len(A)
queries = [[5, 1, 2 ],[-5, 1, 3 ]]

# Function call
print (solve(A,queries))

# This code is contributed by Atul_kumar_Shrivastava

C#

// C# code to implement the approach
using System;

public class GFG {

  // Function to find the remaining value
  public static int solve(int []v, int [,]queries)
  {
    int ans = 0;

    // Loop to calculate the array sum
    for (int i = 0; i < v.Length; i++) {
      ans += v[i];
    }

    // Loop to process the queries
    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;
  }

  // Driver Code
  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 } };

    // Function call
    Console.WriteLine(solve(A, queries));
  }
}

// This code is contributed by AnkThon

Javascript

<script>
// JavaScript code for the above approach

    // Function to find the remaining value
    function solve(v, queries)
    {
        let ans = 0;

        // Loop to calculate the array sum
        for (let i = 0; i < v.length; i++) {
            ans += v[i];
        }

        // Loop to process the queries
        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;
    }
// Driver Code

        let A = [ 1, 4, 3, 2, 4 ];
        let N = A.length;
        let queries = [[ 5, 1, 2 ], [ -5, 1, 3 ]];

        // Function call
        document.write(solve(A, queries));

</script>

Output

9

Time Complexity: O(N + Q)
Auxiliary Space: O(1)