# 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[0] = A[0] 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[0] to D[0] 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[0] to D[0] 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++ 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[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 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[][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 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[0] or D[0] 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[][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 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[][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 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[0] or D[0] 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 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[0] or D[0] 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# 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[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[0] or D[0] 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.

Hello, I am a Computer Science Engineering student currently doing my BTech from Delhi Technological University (formerly DCE) I am an active learner and I like problem-solving in the field of Data Structures & Algorithms & Web-Mobile development

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.

Article Tags :