Data Modelling & AI Data Structure & Algorithm

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

23 June 2025

0

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>

Output

11 32 29

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

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

C++

Java

Python3

C#

Javascript

LangExtract + Milvus: A Practical Guide to Building a Hybrid Document Processing and Search System

Stop Your AI Assistant from Writing Outdated Code with Milvus SDK Code Helper

A Practical Guide for Choosing the Right Vector Database for Your AI Applications

LEAVE A REPLY Cancel reply

Most Popular

Over 30,000 Malicious IPs Target Microsoft Remote Desktop in Global Surge by Husain Parvez

Cyber Threat-Sharing Law Nears Expiration: Experts Warn of Risks by Husain Parvez

The Galaxy S7 is everything I used to love about Samsung

Bose’s TV Speaker drops to its best price yet for Labor Day

EDITOR PICKS

Over 30,000 Malicious IPs Target Microsoft Remote Desktop in Global Surge by Husain Parvez

Cyber Threat-Sharing Law Nears Expiration: Experts Warn of Risks by Husain Parvez

The Galaxy S7 is everything I used to love about Samsung

POPULAR POSTS

Over 30,000 Malicious IPs Target Microsoft Remote Desktop in Global Surge by Husain Parvez

Cyber Threat-Sharing Law Nears Expiration: Experts Warn of Risks by Husain Parvez

The Galaxy S7 is everything I used to love about Samsung

POPULAR CATEGORY

ABOUT US

FOLLOW US