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

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 29
Explanation:
After applying 1st Query 4 times,
Array will be: 5 6 3
After applying 2nd Query 3 times,
Array will be: 11 12 9
After applying 3rd Query 5 times,
Array will be: 11 32 29
Therefore, the final array will br {11, 32, 29}.

Input: arr[] = {1},  M = 1, Q[][] = {{1, 1, 1, 1}}
Output: 2
Explanation:
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:

1. 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 = A considering 0 based indexing.
2. 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.
3. Now update the given array using the difference array. Update A to D and print it. For rest of the elements, do A[i] = A[i-1] + D[i].
4. 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 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:

1. Update values from indices a to b by val*f, only 1 time for each query.
2. 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.
3. Now update the main array using the difference array. Update A to D and print it.
4. For rest of the elements, Update A[i] by (A[i-1] + D[i]).
5. Print the resultant array after the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `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 = A, 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 queries` `void` `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 Call` `void` `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 queries` `void` `queriesInput(vector<``int``>& DiffArray,` `                  ``int` `Q[], ``int` `M)` `{` `    ``// Traverse the query` `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``// Function Call for updates` `        ``UpdateDiffArray(DiffArray, Q[i],` `                        ``Q[i], Q[i],` `                        ``Q[i]);` `    ``}` `}`   `// Function to updates the array` `// using the difference array` `void` `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 or D decides values` `        ``// of rest of the elements` `        ``else` `{` `            ``A[i] = D[i] + A[i - 1];` `        ``}` `    ``}` `}`   `// Function that prints the array` `void` `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 queries` `void` `printAfterUpdate(vector<``int``>& A,` `                      ``int` `Q[], ``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 Code` `int` `main()` `{` `    ``// N = Array size, M = Queries` `    ``int` `N = 3, M = 3;`   `    ``// Given array A[]` `    ``vector<``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);`   `    ``return` `0;` `}`

## Java

 `// Java program for the ` `// above approach` `import` `java.util.*;` `class` `GFG{` `  `  `// N = Array size, ` `// M = Queries` `static` `int` `N = ``3``, M = ``3``;` `  `  `static` `int` `[]A = ``new` `int``[N];`   `//Stores the difference array` `static` `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 queries` `static` `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 Call` `static` `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 queries` `static` `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 array` `static` `void` `UpdateArray()` `{` `  ``// Traverse the array A[]` `  ``for` `(``int` `i = ``0``; i < N; i++) ` `  ``{` `    ``// 1st Element` `    ``if` `(i == ``0``) ` `    ``{` `      ``A[i] = D[i];` `    ``}`   `    ``// A or D decides ` `    ``// values of rest of ` `    ``// the elements` `    ``else` `    ``{` `      ``A[i] = D[i] + A[i - ``1``];` `    ``}` `  ``}` `}`   `// Function that prints ` `// the array` `static` `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 queries` `static` `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 Code` `public` `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

 `# 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 queries` `def` `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 Call` `def` `UpdateDiffArray(DiffArray, Start,` `                    ``End, Val, Freq):` `                        `  `    ``# For range update, difference` `    ``# array is modified` `    ``update(DiffArray, Start ``-` `1``, ` `           ``End ``-` `1``, Val ``*` `Freq)`   `# Function to take queries` `def` `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 array` `def` `UpdateArray(A, D):` `    `  `    ``# Traverse the array A[]` `    ``for` `i ``in` `range``(``len``(A)):`   `        ``# 1st Element` `        ``if` `(i ``=``=` `0``):` `            ``A[i] ``=` `D[i]`   `        ``# A or D decides values` `        ``# of rest of the elements` `        ``else``:` `            ``A[i] ``=` `D[i] ``+` `A[i ``-` `1``]`   `# Function that prints the array` `def` `PrintArray(A):` `    `  `    ``# Print the element` `    ``for` `i ``in` `range``(``len``(A)):` `        ``print``(A[i], end ``=` `" "``)` `        `  `    ``return`   `# Function that prthe array` `# after performing all queries` `def` `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 Code` `if` `__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#

 `// C# program for the` `// above approach` `using` `System;` `class` `GFG{`   `// N = Array size,` `// M = Queries` `static` `int` `N = 3, M = 3;`   `static` `int``[] A = ``new` `int``[N];`   `// Stores the difference array` `static` `int``[] D = ``new` `int``[N + 1];`   `// Function that creates` `// a difference array D[]` `// for A[]` `static` `void` `initializeDiffArray()` `{` `  ``D = A;` `  ``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 queries` `static` `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 Call` `static` `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 queries` `static` `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 array` `static` `void` `UpdateArray()` `{` `  ``// Traverse the array A[]` `  ``for` `(``int` `i = 0; i < N; i++) ` `  ``{` `    ``// 1st Element` `    ``if` `(i == 0) ` `    ``{` `      ``A[i] = D[i];` `    ``}`   `    ``// A or D decides` `    ``// values of rest of` `    ``// the elements` `    ``else` `    ``{` `      ``A[i] = D[i] + A[i - 1];` `    ``}` `  ``}` `}`   `// Function that prints` `// the array` `static` `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 queries` `static` `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 Code` `public` `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`

Output

`11 32 29 `

Time Complexity: O(N + M)
Auxiliary Space: O(N)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.