Find the number of different numbers in the array after applying the given operation q times

Given an array of size N, initially consists of zeroes only. The task is to apply given operation q times and find the number of different numbers in the array except for zeroes.

Operation Format: update(l, r, x):: update a[i] = x for all (l <= i <= r).

Examples:



Input : N = 5, Q = 3,
update(1, 3, 1)
update(0, 1, 2)
update(3, 3, 3)
Output : 3
Explanation : Initially array is {0, 0, 0, 0, 0}. After
applying the operation for the first time array becomes {0, 1, 1, 1, 0}.
After applying the operation for the second time the array becomes
{2, 2, 1, 1, 0}. After applying the operation for the third time the array
becomes {2, 2, 1, 3, 0}. So, a number of different numbers expect zero are 3.

Input : N = 5, Q = 3,
update(1, 1, 4)
update(0, 1, 2)
update(1, 4, 5)
Output : 2

Approach :
Each operation suggest range update, hence try to update the array using lazy propagation. After applying the operation Q times using lazy propagation call a function which finds the number of different numbers in the array. This function uses set to find the count of different numbers.
The update and query operations are similar to what they are in a segment tree with some changes. Whenever an update query gets executed in a segment tree, all the nodes associated with the current node also get updated whereas in lazy propagation those nodes will only get updated when required i.e. we create an array lazy[] of size equal to the given array all of whose elements will be initialized to 0 which means there are no updates for any node initially and any non-zero value at lazy[i] indicates that node i has an update pending which will only be updated while querying (when required).

Below is the implementation of the above approach :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP implementation for above approach
#include <bits/stdc++.h>
using namespace std;
  
#define N 100005
  
// To store the tree in lazy propagation
int lazy[4 * N];
  
// To store the different numbers
set<int> se;
  
// Function to update in the range [x, y) with given value
void update(int x, int y, int value, int id, int l, int r)
{
    // check out of bound
    if (x >= r or l >= y)
        return;
  
    // check for complete overlap
    if (x <= l && r <= y) {
        lazy[id] = value;
        return;
    }
  
    // find the mid number
    int mid = (l + r) / 2;
  
    // check for pending updates
    if (lazy[id])
        lazy[2 * id] = lazy[2 * id + 1] = lazy[id];
  
    // make lazy[id] = 0, so that it has no pending updates
    lazy[id] = 0;
  
    // call for two child nodes
    update(x, y, value, 2 * id, l, mid);
    update(x, y, value, 2 * id + 1, mid, r);
}
  
// Function to find non-zero integers in the range [l, r)
void query(int id, int l, int r)
{
    // if id contains positive number
    if (lazy[id]) {
        se.insert(lazy[id]);
        // There is no need to see the children,
        // because all the interval have same number
        return;
    }
  
    // check for out of bound
    if (r - l < 2)
        return;
  
    // find the middle number
    int mid = (l + r) / 2;
  
    // call for two child nodes
    query(2 * id, l, mid);
    query(2 * id + 1, mid, r);
}
  
// Driver code
int main()
{
    // size of the array and number of queries
    int n = 5, q = 3;
  
    // Update operation for l, r, x, id, 0, n
    update(1, 4, 1, 1, 0, n);
    update(0, 2, 2, 1, 0, n);
    update(3, 4, 3, 1, 0, n);
  
    // Query operation to get answer in the range [0, n-1]
    query(1, 0, n);
  
    // Print the count of non-zero elements
    cout << se.size() << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation for above approach
import java.util.*;
  
class geeks
{
      
    static int N = 100005;
  
    // To store the tree in lazy propagation
    static int[] lazy = new int[4*N];
  
    // To store the different numbers
    static Set<Integer> se = new HashSet<Integer>();
  
    // Function to update in the range [x, y) with given value
    public static void update(int x, int y, int value,
                            int id, int l, int r)
    {
  
        // check out of bound 
        if (x >= r || l >= y) 
            return
      
        // check for complete overlap 
        if (x <= l && r <= y)
        
            lazy[id] = value; 
            return
        
      
        // find the mid number 
        int mid = (l + r) / 2
      
        // check for pending updates 
        if (lazy[id] != 0
            lazy[2 * id] = lazy[2 * id + 1] = lazy[id]; 
      
        // make lazy[id] = 0, so that it has no pending updates 
        lazy[id] = 0
      
        // call for two child nodes 
        update(x, y, value, 2 * id, l, mid); 
        update(x, y, value, 2 * id + 1, mid, r); 
    }
  
    // Function to find non-zero integers in the range [l, r)
    public static void query(int id, int l, int r)
    {
          
        // if id contains positive number
        if (lazy[id] != 0)
        {
            se.add(lazy[id]);
              
            // There is no need to see the children,
            // because all the interval have same number
            return;
        }
  
        // check for out of bound
        if (r - l < 2)
            return;
  
        // find the middle number
        int mid = (l + r) / 2;
  
        // call for two child nodes
        query(2 * id, l, mid);
        query(2 * id + 1, mid, r);
    }
  
    // Driver Code
    public static void main(String[] args)
    {
          
        // size of the array and number of queries
        int n = 5, q = 3;
  
        // Update operation for l, r, x, id, 0, n
        update(1, 4, 1, 1, 0, n);
        update(0, 2, 2, 1, 0, n);
        update(3, 4, 3, 1, 0, n);
  
        // Query operation to get answer in the range [0, n-1]
        query(1, 0, n);
  
        // Print the count of non-zero elements
        System.out.println(se.size());
    }
}
  
// This code is contibuted by
// sanjeev2552

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation for above approach 
N = 100005
  
# To store the tree in lazy propagation 
lazy = [0] * (4 * N); 
  
# To store the different numbers 
se = set() 
  
# Function to update in the range [x, y)
# with given value 
def update(x, y, value, id, l, r) :
      
    # check out of bound 
    if (x >= r or l >= y): 
        return
  
    # check for complete overlap 
    if (x <= l and r <= y) : 
        lazy[id] = value; 
        return
  
    # find the mid number 
    mid = (l + r) // 2
  
    # check for pending updates 
    if (lazy[id]) :
        lazy[2 * id] = lazy[2 * id + 1] = lazy[id]; 
  
    # make lazy[id] = 0, 
    # so that it has no pending updates 
    lazy[id] = 0
  
    # call for two child nodes 
    update(x, y, value, 2 * id, l, mid); 
    update(x, y, value, 2 * id + 1, mid, r); 
  
# Function to find non-zero integers
# in the range [l, r) 
def query(id, l, r) : 
      
    # if id contains positive number 
    if (lazy[id]) :
          
        se.add(lazy[id]); 
          
        # There is no need to see the children, 
        # because all the interval have same number 
        return
      
    # check for out of bound 
    if (r - l < 2) :
        return
  
    # find the middle number 
    mid = (l + r) // 2
  
    # call for two child nodes 
    query(2 * id, l, mid); 
    query(2 * id + 1, mid, r); 
  
# Driver code 
if __name__ == "__main__" :
  
    # size of the array and number of queries 
    n = 5; q = 3
  
    # Update operation for l, r, x, id, 0, n 
    update(1, 4, 1, 1, 0, n); 
    update(0, 2, 2, 1, 0, n); 
    update(3, 4, 3, 1, 0, n); 
  
    # Query operation to get answer
    # in the range [0, n-1] 
    query(1, 0, n); 
  
    # Print the count of non-zero elements 
    print(len(se)); 
      
# This code is contributed by AnkitRai01

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation for above approach
using System;
using System.Collections.Generic;
      
public class geeks
{
      
    static int N = 100005;
  
    // To store the tree in lazy propagation
    static int[] lazy = new int[4*N];
  
    // To store the different numbers
    static HashSet<int> se = new HashSet<int>();
  
    // Function to update in the range [x, y) with given value
    public static void update(int x, int y, int value,
                            int id, int l, int r)
    {
  
        // check out of bound 
        if (x >= r || l >= y) 
            return
      
        // check for complete overlap 
        if (x <= l && r <= y)
        
            lazy[id] = value; 
            return
        
      
        // find the mid number 
        int mid = (l + r) / 2; 
      
        // check for pending updates 
        if (lazy[id] != 0) 
            lazy[2 * id] = lazy[2 * id + 1] = lazy[id]; 
      
        // make lazy[id] = 0, so that it has no pending updates 
        lazy[id] = 0; 
      
        // call for two child nodes 
        update(x, y, value, 2 * id, l, mid); 
        update(x, y, value, 2 * id + 1, mid, r); 
    }
  
    // Function to find non-zero integers in the range [l, r)
    public static void query(int id, int l, int r)
    {
          
        // if id contains positive number
        if (lazy[id] != 0)
        {
            se.Add(lazy[id]);
              
            // There is no need to see the children,
            // because all the interval have same number
            return;
        }
  
        // check for out of bound
        if (r - l < 2)
            return;
  
        // find the middle number
        int mid = (l + r) / 2;
  
        // call for two child nodes
        query(2 * id, l, mid);
        query(2 * id + 1, mid, r);
    }
  
    // Driver Code
    public static void Main(String[] args)
    {
          
        // size of the array and number of queries
        int n = 5, q = 3;
  
        // Update operation for l, r, x, id, 0, n
        update(1, 4, 1, 1, 0, n);
        update(0, 2, 2, 1, 0, n);
        update(3, 4, 3, 1, 0, n);
  
        // Query operation to get answer in the range [0, n-1]
        query(1, 0, n);
  
        // Print the count of non-zero elements
        Console.WriteLine(se.Count);
    }
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

3


My Personal Notes arrow_drop_up

pawanasipugmailcom

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.