Skip to content
Related Articles

Related Articles

Improve Article
Two Dimensional Difference Array
  • Difficulty Level : Medium
  • Last Updated : 08 Jan, 2021

Given a matrix of dimensions N * M and a 2D array Queries[][] with each query of the form {k, r1, c1, r2, c2}, the task is to add k to allthe cells kting in the submatrix (r1, c1) to (r2, c2)

Examples:

Input: A[][] = {{1, 2, 3}, {1, 1, 0}, {4, -2, 2}}, Queries[][] = {{2, 0, 0, 1, 1}, {-1, 1, 0, 2, 2}} 
Output:
3 4 3
2 2 -1
3 -3 1
Explanation: 
Query 1: Matrix modifies to {{3, 4, 3}, {3, 3, 0}, {4, -2, 2}
Query 2: Matrix modifies to {{3, 4, 3}, {2, 2, -1}, {3, -3, 1}

Input: A[][] = {{1, 2, 3}, { 4, 5, 6}, {7, 8, 9}}, Queries[][] = {{1, 1, 1, 2, 2}, {2, 0, 1, 0, 2}}
Output:
1 4 5
4 6 7
7 9 10

Approach: The idea is based on Difference Array | Range update query in O(1). Follow the steps below to solve the problem:



  • Initialize a 2D difference array D[][], such that D[i][j] stores A[i][j] – A[i][j – 1] (for 0 ≤ i ≤ N and 0 < j < M) or D[i][j] = A[i][j] otherwise.
  • Traverse each row and compute and store the difference between adjacent elements.
  • To update the submatrix (r1, c1) to (r2, c2), traverse from r1 to r2 (assuming r1 < r2 and c1 < c2) and update D[i][c1] = D[i][c1] + k and D[i][c2 + 1] = D[i][c2 + 1] – k.
  • Finally, print the modified array as D[i][j] + A[i][j-1] for j > 0 or D[i][j] for j = 0.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
#define N 3
#define M 3
 
// Function to initialize the difference array
void intializeDiff(int D[N][M + 1],
                   int A[N][M])
{
    for (int i = 0; i < N; i++) {
        D[i][0] = A[i][0];
        D[i][M] = 0;
    }
    for (int i = 0; i < N; i++) {
        for (int j = 1; j < M; j++)
            D[i][j] = A[i][j] - A[i][j - 1];
    }
}
 
// Function to add k to the specified
// submatrix (r1, c1) to (r2, c2)
void update(int D[N][M + 1], int k,
            int r1, int c1, int r2,
            int c2)
{
    for (int i = r1; i <= r2; i++) {
        D[i][c1] += k;
        D[i][c2 + 1] -= k;
    }
}
 
// Function to print the modified array
void printArray(int A[N][M], int D[N][M + 1])
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (j == 0)
                A[i][j] = D[i][j];
            else
                A[i][j] = D[i][j] + A[i][j - 1];
            cout << A[i][j] << " ";
        }
        cout << endl;
    }
}
 
// Function to perform the given queries
void performQueries(int A[N][M],
                    vector<vector<int> > Queries)
{
    // Difference array
    int D[N][M + 1];
 
    // Function to initialize
    // the difference array
    intializeDiff(D, A);
 
    // Count of queries
    int Q = Queries.size();
 
    // Perform Queries
    for (int i = 0; i < Q; i++) {
        update(D, Queries[i][0],
               Queries[i][1], Queries[i][2],
               Queries[i][3], Queries[i][4]);
    }
 
    printArray(A, D);
}
 
// Driver Code
int main()
{
 
    // Given Matrix
    int A[N][M] = { { 1, 2, 3 },
                    { 1, 1, 0 },
                    { 4, -2, 2 } };
 
    // Given Queries
    vector<vector<int> > Queries
        = { { 2, 0, 0, 1, 1 },
            { -1, 1, 0, 2, 2 } };
 
    performQueries(A, Queries);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
     
static int N = 3;
static int M = 3;
  
// Function to initialize the difference array
static void intializeDiff(int D[][], int A[][])
{
    for(int i = 0; i < N; i++)
    {
        D[i][0] = A[i][0];
        D[i][M] = 0;
    }
    for(int i = 0; i < N; i++)
    {
        for(int j = 1; j < M; j++)
            D[i][j] = A[i][j] - A[i][j - 1];
    }
}
    
// Function to add k to the specified
// submatrix (r1, c1) to (r2, c2)
static void update(int D[][], int k,
                   int r1, int c1,
                   int r2, int c2)
{
    for(int i = r1; i <= r2; i++)
    {
        D[i][c1] += k;
        D[i][c2 + 1] -= k;
    }
}
    
// Function to print the modified array
static void printArray(int A[][], int D[][])
{
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < M; j++)
        {
            if (j == 0)
                A[i][j] = D[i][j];
            else
                A[i][j] = D[i][j] + A[i][j - 1];
                  
            System.out.print(A[i][j] + " ");
        }
        System.out.println();
    }
}
    
// Function to perform the given queries
static void performQueries(int A[][],
                           Vector<Vector<Integer>> Queries)
{
     
    // Difference array
    int D[][] = new int[N][M + 1];
    
    // Function to initialize
    // the difference array
    intializeDiff(D, A);
    
    // Count of queries
    int Q = Queries.size();
    
    // Perform Queries
    for(int i = 0; i < Q; i++)
    {
        update(D, Queries.get(i).get(0),
                  Queries.get(i).get(1),
                  Queries.get(i).get(2),
                  Queries.get(i).get(3),
                  Queries.get(i).get(4));
    }
    printArray(A, D);
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given Matrix
    int A[][] = { { 1, 2, 3 },
                  { 1, 1, 0 },
                  { 4, -2, 2 } };
      
    // Given Queries
    Vector<Vector<Integer>> Queries = new Vector<Vector<Integer>>();
    Vector<Integer> list1 = new Vector<Integer>();
    list1.add(2);
    list1.add(0);
    list1.add(0);
    list1.add(1);
    list1.add(1);
     
    Vector<Integer> list2 = new Vector<Integer>();
    list2.add(-1);
    list2.add(1);
    list2.add(0);
    list2.add(2);
    list2.add(2);
     
    Queries.add(list1);
    Queries.add(list2);
      
    performQueries(A, Queries);
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python3 Program to implement
# the above approach
N = 3
M = 3
  
# Function to initialize the difference array
def intializeDiff(D, A):
    for i in range(N):       
        D[i][0] = A[i][0];
        D[i][M] = 0;  
    for i in range(N):
        for j in range(1, M):
            D[i][j] = A[i][j] - A[i][j - 1];
      
# Function to add k to the specified
# submatrix (r1, c1) to (r2, c2)
def update(D, k, r1, c1, r2, c2):
    for i in range(r1, r2 + 1):
        D[i][c1] += k;
        D[i][c2 + 1] -= k;
 
# Function to print the modified array
def printArray(A, D):  
    for i in range(N):
        for j in range(M):  
            if (j == 0):
                A[i][j] = D[i][j];
            else:
                A[i][j] = D[i][j] + A[i][j - 1];               
            print(A[i][j], end = ' ')
        print()
         
# Function to perform the given queries
def performQueries(A, Queries):
 
    # Difference array
    D = [[0 for j in range(M + 1)] for i in range(N)]
  
    # Function to initialize
    # the difference array
    intializeDiff(D, A);
  
    # Count of queries
    Q = len(Queries)
  
    # Perform Queries
    for i in range(Q):   
        update(D, Queries[i][0],
               Queries[i][1], Queries[i][2],
               Queries[i][3], Queries[i][4]);
      
    printArray(A, D);
  
# Driver Code
if __name__=='__main__':
  
    # Given Matrix
    A = [ [ 1, 2, 3 ],
                    [ 1, 1, 0 ],
                    [ 4, -2, 2 ] ];
  
    # Given Queries
    Queries = [ [ 2, 0, 0, 1, 1 ],[ -1, 1, 0, 2, 2 ] ];
  
    performQueries(A, Queries);
 
  # This code is contributed by Pratham76

C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
static int N = 3;
static int M = 3;
 
// Function to initialize the difference array
static void intializeDiff(int[,] D, int[,] A)
{
    for(int i = 0; i < N; i++)
    {
        D[i, 0] = A[i, 0];
        D[i, M] = 0;
    }
    for(int i = 0; i < N; i++)
    {
        for(int j = 1; j < M; j++)
            D[i, j] = A[i, j] - A[i, j - 1];
    }
}
   
// Function to add k to the specified
// submatrix (r1, c1) to (r2, c2)
static void update(int[,] D, int k,
                   int r1, int c1,
                   int r2, int c2)
{
    for(int i = r1; i <= r2; i++)
    {
        D[i, c1] += k;
        D[i, c2 + 1] -= k;
    }
}
   
// Function to print the modified array
static void printArray(int[,] A, int[,] D)
{
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < M; j++)
        {
            if (j == 0)
                A[i, j] = D[i, j];
            else
                A[i, j] = D[i, j] + A[i, j - 1];
                 
            Console.Write(A[i, j] + " ");
        }
        Console.WriteLine();
    }
}
   
// Function to perform the given queries
static void performQueries(int[,] A,
                 List<List<int>> Queries)
{
     
    // Difference array
    int[,] D = new int[N, M + 1];
   
    // Function to initialize
    // the difference array
    intializeDiff(D, A);
   
    // Count of queries
    int Q = Queries.Count;
   
    // Perform Queries
    for(int i = 0; i < Q; i++)
    {
        update(D, Queries[i][0],
                  Queries[i][1], Queries[i][2],
                  Queries[i][3], Queries[i][4]);
    }
    printArray(A, D);
}
 
// Driver Code
static void Main()
{
     
    // Given Matrix
    int[,] A = { { 1, 2, 3 },
                 { 1, 1, 0 },
                 { 4, -2, 2 } };
     
    // Given Queries
    List<List<int>> Queries = new List<List<int>>();
    Queries.Add(new List<int>{ 2, 0, 0, 1, 1 });
    Queries.Add(new List<int>{ -1, 1, 0, 2, 2 });
     
    performQueries(A, Queries);
}
}
 
// This code is contributed by divyesh072019

Output:

3 4 3
2 2 -1
3 -3 1

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

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :