Queries to increment array elements in a given range by a given value for a given number of times - GeeksforGeeks

29 May, 2021
Given an array, arr[] of N positive integers and M queries of the form {a, b, val, f}. The task is to print the array after performing each query to increment array elements in the range [a, b] by a value val f number of times.
Examples:
Input: arr[] = {1, 2, 3}, M=3, Q[][] = {{1, 2, 1, 4}, {1, 3, 2, 3}, {2, 3, 4, 5}}Output: 11 32 29Explanation: After applying 1st Query 4 times, Array will be: 5 6 3After applying 2nd Query 3 times, Array will be: 11 12 9After applying 3rd Query 5 times, Array will be: 11 32 29Therefore, the final array will br {11, 32, 29}.
Input: arr[] = {1}, M = 1, Q[][] = {{1, 1, 1, 1}}Output: 2Explanation: After applying 1st and the only query 1 time only.Array will be: 2
Naive Approach: The simplest approach is to perform each query on the given array i.e., for each query {a, b, val, f} traverse the array over the range [a, b] and increase each element by value val to f number of times. Print the array after performing each query.
Time Complexity: O(N * M * max(Freq))Auxiliary Space: O(1)
Better Approach: The idea is based on the difference array which can be used in Range Update operations. Below are the steps:
Find the difference array D[] of a given array A[] is defined as D[i] = (A[i] – A[i – 1]) (0 < i < N) and D[0] = A[0] considering 0 based indexing.Add val to D[a – 1] and subtract it from D[(b – 1) + 1], i.e., D[a – 1] += val, D[(b – 1) + 1] -= val. Perform this operation Freq number of times.Now update the given array using the difference array. Update A[0] to D[0] and print it. For rest of the elements, do A[i] = A[i-1] + D[i].Print the resultant array after the above steps.
Find the difference array D[] of a given array A[] is defined as D[i] = (A[i] – A[i – 1]) (0 < i < N) and D[0] = A[0] considering 0 based indexing.
Add val to D[a – 1] and subtract it from D[(b – 1) + 1], i.e., D[a – 1] += val, D[(b – 1) + 1] -= val. Perform this operation Freq number of times.
Now update the given array using the difference array. Update A[0] to D[0] and print it. For rest of the elements, do A[i] = A[i-1] + D[i].
Print the resultant array after the above steps.
Time Complexity: O(N + M * max(Freq))Auxiliary Space: O(N) Extra space for Difference Array
Efficient Approach: This approach is similar to the previous approach but an extended version of the application of a difference array. Previously the task was to update values from indices a to b by val, f number of times. Here instead of calling the range update function f number of times, call it only once for each query:
Update values from indices a to b by val*f, only 1 time for each query.Add val*f to D[a – 1] and subtract it from D[(b – 1) + 1], i.e., increase D[a – 1] by val*f, and decrease D[b] by val*f.Now update the main array using the difference array. Update A[0] to D[0] and print it.For rest of the elements, Update A[i] by (A[i-1] + D[i]).Print the resultant array after the above steps.
Update values from indices a to b by val*f, only 1 time for each query.
Add val*f to D[a – 1] and subtract it from D[(b – 1) + 1], i.e., increase D[a – 1] by val*f, and decrease D[b] by val*f.
Now update the main array using the difference array. Update A[0] to D[0] and print it.
For rest of the elements, Update A[i] by (A[i-1] + D[i]).
Print the resultant array after the above steps.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; // Function that creates a difference// array D[] for A[]vector<int> initializeDiffArray(    vector<int>& A){    int N = A.size();     // Stores the difference array    vector<int> D(N + 1);     D[0] = A[0], D[N] = 0;     // Update difference array D[]    for (int i = 1; i < N; i++)        D[i] = A[i] - A[i - 1];     // Return difference array    return D;} // Function that performs the range// update queriesvoid update(vector<int>& D, int l,            int r, int x){    // Update the ends of the range    D[l] += x;    D[r + 1] -= x;} // Function that perform all query// once with modified update Callvoid UpdateDiffArray(vector<int>& DiffArray,                     int Start, int End,                     int Val, int Freq){    // For range update, difference    // array is modified    update(DiffArray, Start - 1,           End - 1, Val * Freq);} // Function to take queriesvoid queriesInput(vector<int>& DiffArray,                  int Q[][4], int M){    // Traverse the query    for (int i = 0; i < M; i++) {         // Function Call for updates        UpdateDiffArray(DiffArray, Q[i][0],                        Q[i][1], Q[i][2],                        Q[i][3]);    }} // Function to updates the array// using the difference arrayvoid UpdateArray(vector<int>& A,                 vector<int>& D){    // Traverse the array A[]    for (int i = 0; i < A.size(); i++) {         // 1st Element        if (i == 0) {            A[i] = D[i];        }         // A[0] or D[0] decides values        // of rest of the elements        else {            A[i] = D[i] + A[i - 1];        }    }} // Function that prints the arrayvoid PrintArray(vector<int>& A){    // Print the element    for (int i = 0; i < A.size(); i++) {        cout << A[i] << " ";    }     return;} // Function that print the array// after performing all queriesvoid printAfterUpdate(vector<int>& A,                      int Q[][4], int M){    // Create and fill difference    // array for range updates    vector<int> DiffArray        = initializeDiffArray(A);     queriesInput(DiffArray, Q, M);     // Now update Array A using    // Difference Array    UpdateArray(A, DiffArray);     // Print updated Array A    // after M queries    PrintArray(A);} // Driver Codeint main(){    // N = Array size, M = Queries    int N = 3, M = 3;     // Given array A[]    vector<int> A{ 1, 2, 3 };     // Queries    int Q[][4] = { { 1, 2, 1, 4 },                   { 1, 3, 2, 3 },                   { 2, 3, 4, 5 } };     // Function Call    printAfterUpdate(A, Q, M);     return 0;}
// Java program for the// above approachimport java.util.*;class GFG{   // N = Array size,// M = Queriesstatic int N = 3, M = 3;   static int []A = new int[N]; //Stores the difference arraystatic int []D = new int[N + 1];   // Function that creates// a difference array D[]// for A[]static void initializeDiffArray(){  D[0] = A[0];  D[N] = 0;   // Update difference array D[]  for (int i = 1; i < N; i++)    D[i] = A[i] - A[i - 1];} // Function that performs// the range update queriesstatic void update(int l,                   int r, int x){  // Update the ends  // of the range  D[l] += x;  D[r + 1] -= x;} // Function that perform all query// once with modified update Callstatic void UpdateDiffArray(int Start, int End,                            int Val, int Freq){  // For range update, difference  // array is modified  update(Start - 1,         End - 1, Val * Freq);} // Function to take queriesstatic void queriesInput(  int Q[][]){  // Traverse the query  for (int i = 0; i < M; i++)  {    // Function Call for updates    UpdateDiffArray(Q[i][0], Q[i][1],                    Q[i][2], Q[i][3]);  }} // Function to updates the array// using the difference arraystatic void UpdateArray(){  // Traverse the array A[]  for (int i = 0; i < N; i++)  {    // 1st Element    if (i == 0)    {      A[i] = D[i];    }     // A[0] or D[0] decides    // values of rest of    // the elements    else    {      A[i] = D[i] + A[i - 1];    }  }} // Function that prints// the arraystatic void PrintArray(){  // Print the element  for (int i = 0; i < N; i++)  {    System.out.print(A[i] + i +                     1 + " ");  }  return;} // Function that print the array// after performing all queriesstatic void printAfterUpdate(int []A,                             int Q[][], int M){  // Create and fill difference  // array for range updates  initializeDiffArray();   queriesInput( Q);   // Now update Array  // A using Difference  // Array  UpdateArray();   // Print updated Array A  // after M queries  PrintArray();} // Driver Codepublic static void main(String[] args){  // Given array A[]  int []A = {1, 2, 3};   // Queries  int [][]Q = {{1, 2, 1, 4},               {1, 3, 2, 3},               {2, 3, 4, 5}};   // Function Call  printAfterUpdate(A, Q, M);}} // This code is contributed by gauravrajput1
# Python3 program for the above approach # Function that creates a difference# array D[] for A[]def initializeDiffArray(A):         N = len(A)     # Stores the difference array    D = [0] * (N + 1)     D[0] = A[0]    D[N] = 0     # Update difference array D[]    for i in range(1, N):        D[i] = A[i] - A[i - 1]     # Return difference array    return D # Function that performs the range# update queriesdef update(D, l, r, x):         # Update the ends of the range    D[l] += x    D[r + 1] -= x # Function that perform all query# once with modified update Calldef UpdateDiffArray(DiffArray, Start,                    End, Val, Freq):                             # For range update, difference    # array is modified    update(DiffArray, Start - 1,           End - 1, Val * Freq) # Function to take queriesdef queriesInput(DiffArray, Q, M):         # Traverse the query    for i in range(M):         # Function Call for updates        UpdateDiffArray(DiffArray, Q[i][0],                          Q[i][1], Q[i][2],                          Q[i][3]) # Function to updates the array# using the difference arraydef UpdateArray(A, D):         # Traverse the array A[]    for i in range(len(A)):         # 1st Element        if (i == 0):            A[i] = D[i]         # A[0] or D[0] decides values        # of rest of the elements        else:            A[i] = D[i] + A[i - 1] # Function that prints the arraydef PrintArray(A):         # Print the element    for i in range(len(A)):        print(A[i], end = " ")             return # Function that print the array# after performing all queriesdef printAfterUpdate(A, Q, M):         # Create and fill difference    # array for range updates    DiffArray = initializeDiffArray(A)     queriesInput(DiffArray, Q, M)     # Now update Array A using    # Difference Array    UpdateArray(A, DiffArray)     # Prupdated Array A    # after M queries    PrintArray(A) # Driver Codeif __name__ == '__main__':         # N = Array size, M = Queries    N = 3    M = 3     # Given array A[]    A = [ 1, 2, 3 ]     # Queries    Q = [ [ 1, 2, 1, 4 ],          [ 1, 3, 2, 3 ],          [ 2, 3, 4, 5 ] ]     # Function call    printAfterUpdate(A, Q, M) # This code is contributed by mohit kumar 29
// C# program for the// above approachusing System;class GFG{ // N = Array size,// M = Queriesstatic int N = 3, M = 3; static int[] A = new int[N]; // Stores the difference arraystatic int[] D = new int[N + 1]; // Function that creates// a difference array D[]// for A[]static void initializeDiffArray(){  D[0] = A[0];  D[N] = 0;   // Update difference array D[]  for (int i = 1; i < N; i++)    D[i] = A[i] - A[i - 1];} // Function that performs// the range update queriesstatic void update(int l,                   int r, int x){  // Update the ends  // of the range  D[l] += x;  D[r + 1] -= x;} // Function that perform all query// once with modified update Callstatic void UpdateDiffArray(int Start, int End,                            int Val, int Freq){  // For range update, difference  // array is modified  update(Start - 1,         End - 1, Val * Freq);} // Function to take queriesstatic void queriesInput(int[, ] Q){  // Traverse the query  for (int i = 0; i < M; i++)  {    // Function Call for updates    UpdateDiffArray(Q[i, 0], Q[i, 1],                    Q[i, 2], Q[i, 3]);  }} // Function to updates the array// using the difference arraystatic void UpdateArray(){  // Traverse the array A[]  for (int i = 0; i < N; i++)  {    // 1st Element    if (i == 0)    {      A[i] = D[i];    }     // A[0] or D[0] decides    // values of rest of    // the elements    else    {      A[i] = D[i] + A[i - 1];    }  }} // Function that prints// the arraystatic void PrintArray(){  // Print the element  for (int i = 0; i < N; i++)  {    Console.Write(A[i] + i +                  1 + " ");  }  return;} // Function that print the array// after performing all queriesstatic void printAfterUpdate(int[] A,                             int[, ] Q, int M){  // Create and fill difference  // array for range updates  initializeDiffArray();   queriesInput(Q);   // Now update Array  // A using Difference  // Array  UpdateArray();   // Print updated Array A  // after M queries  PrintArray();} // Driver Codepublic static void Main(String[] args){  // Given array A[]  int[] A = {1, 2, 3};   // Queries  int[, ] Q = {{1, 2, 1, 4},               {1, 3, 2, 3},               {2, 3, 4, 5}};   // Function Call  printAfterUpdate(A, Q, M);} // This code is contributed by Chitranayal
<script> // Javascript program to implement// the above approach // N = Array size,// M = Querieslet N = 3, M = 3;   let A = new Array(N).fill(0); //Stores the difference arraylet D = new Array(N+1).fill(0);   // Function that creates// a difference array D[]// for A[]function initializeDiffArray(){  D[0] = A[0];  D[N] = 0;   // Update difference array D[]  for (let i = 1; i < N; i++)    D[i] = A[i] - A[i - 1];} // Function that performs// the range update queriesfunction update(l, r, x){  // Update the ends  // of the range  D[l] += x;  D[r + 1] -= x;} // Function that perform all query// once with modified update Callfunction UpdateDiffArray(Start, End, Val, Freq){  // For range update, difference  // array is modified  update(Start - 1,         End - 1, Val * Freq);} // Function to take queriesfunction queriesInput(Q){  // Traverse the query  for (let i = 0; i < M; i++)  {    // Function Call for updates    UpdateDiffArray(Q[i][0], Q[i][1],                    Q[i][2], Q[i][3]);  }} // Function to updates the array// using the difference arrayfunction UpdateArray(){  // Traverse the array A[]  for (let i = 0; i < N; i++)  {    // 1st Element    if (i == 0)    {      A[i] = D[i];    }     // A[0] or D[0] decides    // values of rest of    // the elements    else    {      A[i] = D[i] + A[i - 1];    }  }} // Function that print// the arrayfunction PrintArray(){  // Print the element  for (let i = 0; i < N; i++)  {    document.write(A[i] + i +                     1 + " ");  }  return;} // Function that print the array// after performing all queriesfunction printAfterUpdate(A, Q, M){  // Create and fill difference  // array for range updates  initializeDiffArray();   queriesInput( Q);   // Now update Array  // A using Difference  // Array  UpdateArray();   // Print updated Array A  // after M queries  PrintArray();} // Driver Code        // Given array A[]  let a = [1, 2, 3];   // Queries  let Q = [[1, 2, 1, 4],               [1, 3, 2, 3],               [2, 3, 4, 5]];   // Function Call  printAfterUpdate(a, Q, M);          </script>
11 32 29 
Time Complexity: O(N + M)Auxiliary Space: O(N)
mohit kumar 29
GauravRajput1
ukasp
avijitmondal1998
nidhi_biet
ankita_saini
array-range-queries
prefix-sum
Arrays
Mathematical
prefix-sum
Arrays
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
Program for Fibonacci numbers
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Coin Change | DP-7