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

• Difficulty Level : Easy
• Last Updated : 10 Jun, 2022

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 be {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 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:

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++

 `// 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

 `// 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

 `# 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 print the 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)` `    ``# Print updated 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[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`

## Javascript

 ``

Output

`11 32 29 `

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

My Personal Notes arrow_drop_up