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

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.

Below is the implementation of the above approach:

C++

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

<script>
 
// Javascript program to implement
// the above approach
 
// N = Array size,
// M = Queries
let N = 3, M = 3;
   
let A = new Array(N).fill(0);
 
//Stores the difference array
let 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 queries
function 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 Call
function UpdateDiffArray(Start, End, Val, Freq)
{
  // For range update, difference
  // array is modified
  update(Start - 1,
         End - 1, Val * Freq);
}
 
// Function to take queries
function 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 array
function 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 array
function 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 queries
function 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>