Queries to print count of distinct array elements after replacing element at index P by a given element

Last Updated : 28 Feb, 2022

Given an array arr[] consisting of N integers and 2D array queries[][] consisting of Q queries of the form {p, x}, the task for each query is to replace the element at position p with x and print the count of distinct elements present in the array.

Examples:

Input: Q = 3, arr[] = {2, 2, 5, 5, 4, 6, 3}, queries[][] = {{1, 7}, {6, 8}, {7, 2}}
Output: {6, 6, 5}
Explanation:
The total distinct elements after each query (one-based indexing):
Query 1: p = 1 and x = 7. Therefore, arr[1] = 7 and arr[] becomes {7, 2, 5, 5, 4, 6, 3}. Hence, distinct elements = 6.
Query 2: p = 6 and x = 8. Therefore, arr[6] = 8 and arr[] becomes {7, 2, 5, 5, 4, 8, 3}. Hence, distinct elements = 6.
Query 3: p = 7 and x = 2. Therefore, arr[7] = 2 and arr[] becomes {7, 2, 5, 5, 4, 8, 2}. Hence, distinct elements = 5.

Input: Q = 2, arr[] = {1, 1, 1, 1}, queries[][] = {{2, 2}, {3, 3}}
Output: {2, 3}
Explanation:
The total distinct elements after each query (one-based indexing):
Query 1: p = 2 and x = 2. Therefore, arr[2] = 2 and arr[] becomes {1, 2, 1, 1}. Hence, distinct elements = 2.
Query 2: p = 3 and x = 3. Therefore, arr[3] = 3 and arr[] becomes {1, 2, 3, 1}. Hence, distinct elements = 3.

Naive approach: The simplest approach is to update the given array for each query and insert all the elements of the updated array into a Set. Print the size of the set as the count of distinct array elements.

Below is the implementation of the above approach:

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
#define R 3
#define C 2

// Function to the total 
// number of distinct elements 
// after each query update
void Distinct(int arr[], int n, 
              int p, int x)
{
  // Update the array
  arr[p - 1] = x;

  // Store distinct elements
  set<int> set;
  for (int i = 0; i < n; i++) 
  {
    set.insert(arr[i]);
  }

  // Print the size
  cout << set.size() << " ";
}

// Function to print the count of
// distinct elements for each query
void updateArray(int arr[], int n, 
                 int queries[R][C], 
                 int q)
{
  // Traverse the query
  for (int i = 0; i < q; i++) 
  {
    // Function Call to update
    // each query
    Distinct(arr, n, 
             queries[i][0], 
             queries[i][1]);
  }
}

// Driver Code
int main()
{
  // Given array arr[]
  int arr[] = {2, 2, 5, 
               5, 4, 6, 3};

  int N = sizeof(arr) / 
          sizeof(arr[0]);

  int Q = 3;

  // Given queries
  int queries[R][C] = {{1, 7}, 
                       {6, 8}, 
                       {7, 2}};

  // Function Call
  updateArray(arr, N, 
              queries, Q);
}

// This code is contributed by gauravrajput1

Java

// Java program for the above approach
import java.io.*;
import java.util.*;

class GFG {

    // Function to the total number
    // of distinct elements after each
    // query update
    static void Distinct(int arr[], int n,
                         int p, int x)
    {
        // Update the array
        arr[p - 1] = x;

        // Store distinct elements
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < n; i++) {
            set.add(arr[i]);
        }

        // Print the size
        System.out.print(set.size() + " ");
    }

    // Function to print the count of
    // distinct elements for each query
    static void updateArray(
        int arr[], int n,
        int queries[][], int q)
    {
        // Traverse the query
        for (int i = 0; i < q; i++) {

            // Function Call to update
            // each query
            Distinct(arr, n, queries[i][0],
                     queries[i][1]);
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        int[] arr = { 2, 2, 5, 5, 4, 6, 3 };

        int N = arr.length;

        int Q = 3;

        // Given queries
        int queries[][]
            = new int[][] { { 1, 7 },
                            { 6, 8 },
                            { 7, 2 } };

        // Function Call
        updateArray(arr, N, queries, Q);
    }
}

Python3

# Python3 program for the
# above approach

# Function to the total number
# of distinct elements after
# each query update
def Distinct(arr, n, p, x):
  
    # Update the array
    arr[p - 1] = x;

    # Store distinct elements
    s = set();


    for i in range(n):
        s.add(arr[i]);

    # Print the size
    print(len(s), end = " ");

# Function to print count 
# of distinct elements for 
# each query
def updateArray(arr, n, 
                queries, q):
  
    # Traverse the query
    for i in range(0, q):
      
        # Function Call to update
        # each query
        Distinct(arr, n, 
                 queries[i][0], 
                 queries[i][1]);

# Driver Code
if __name__ == '__main__':
  
    # Given array arr
    arr = [2, 2, 5, 
           5, 4, 6, 3];

    N = len(arr);
    Q = 3;

    # Given queries
    queries = [[1, 7], 
               [6, 8], 
               [7, 2]];

    # Function Call
    updateArray(arr, N, queries, Q);

# This code is contributed by shikhasingrajput

// C# program for the 
// above approach
using System;
using System.Collections.Generic;
class GFG{

// Function to the total number
// of distinct elements after each
// query update
static void Distinct(int []arr, int n,
                     int p, int x)
{
  // Update the array
  arr[p - 1] = x;

  // Store distinct elements
  HashSet<int> set = 
          new HashSet<int>();

  for (int i = 0; i < n; i++) 
  {
    set.Add(arr[i]);
  }

  // Print the size
  Console.Write(set.Count + " ");
}

// Function to print the count of
// distinct elements for each query
static void updateArray(int []arr, int n,
                        int [,]queries, int q)
{
  // Traverse the query
  for (int i = 0; i < q; i++) 
  {
    // Function Call to update
    // each query
    Distinct(arr, n, queries[i, 0], 
             queries[i, 1]);
  }
}

// Driver Code
public static void Main(String[] args)
{
  // Given array []arr
  int[] arr = {2, 2, 5, 5, 
               4, 6, 3};

  int N = arr.Length;
  int Q = 3;

  // Given queries
  int [,]queries = new int[,] {{1, 7},
                               {6, 8}, 
                               {7, 2}};

  // Function Call
  updateArray(arr, N, queries, Q);
}
}

// This code is contributed by gauravrajput1

JavaScript

<script>

// Javascript Program to implement
// the above approach
var R = 3
var C = 2;

// Function to the total 
// number of distinct elements 
// after each query update
function Distinct(arr, n, p, x)
{
  // Update the array
  arr[p - 1] = x;

  // Store distinct elements
  var set = new Set();
  for (var i = 0; i < n; i++) 
  {
    set.add(arr[i]);
  }

  // Print the size
  document.write( set.size + " ");
}

// Function to print the count of
// distinct elements for each query
function updateArray(arr, n, queries, q)
{
  // Traverse the query
  for (var i = 0; i < q; i++) 
  {
    // Function Call to update
    // each query
    Distinct(arr, n, 
             queries[i][0], 
             queries[i][1]);
  }
}

// Driver Code
// Given array arr[]
var arr = [2, 2, 5, 
             5, 4, 6, 3];
var N = arr.length;
var Q = 3;
// Given queries
var queries = [[1, 7], 
                     [6, 8], 
                     [7, 2]];
// Function Call
updateArray(arr, N, 
            queries, Q);

</script>

Output

6 6 5

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

Efficient Approach: To optimize the above approach, the idea is to store the frequency of each array element in a Map and then traverse each query and print the size of the map after each update. Follow the below steps to solve the problem:

Store the frequency of each element in a Map M.
For each query {p, x}, perform the following steps:
- Decrease the frequency of arr[p] by 1 in the Map M. If its frequency reduces to 0, remove that element from the Map.
- Update arr[p] = x and increment the frequency of x by 1 in the Map if it is already present. Otherwise, add element x in the Map setting its frequency as 1.
For each query in the above steps, print the size of the Map as the count of the distinct array elements.

Below is the implementation of the above approach:

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

#define Q 3
// Function to store the frequency
// of each element in the Map
void store(int arr[], int n,
           map<int, int> &map)
{
  for (int i = 0; i < n; i++) 
  {
    // Store the frequency of
    // element arr[i]
    map[arr[i]]++;
  }
}

// Function to update an array 
// and map & to find the 
// distinct elements
void Distinct(int arr[], int n, 
              int p, int x,
              map<int, int> &map)
{
  // Decrease the element 
  // if it was previously 
  // present in Map
  map[arr[p - 1]] = 
          map[arr[p - 1]] - 1;

  if (map[arr[p - 1]] == 0)
    map.erase(arr[p - 1]);

  // Add the new element 
  // to map
  map[x]++;

  // Update the array
  arr[p - 1] = x;
  
  // Print the count of 
  // distinct elements
  cout << (map.size()) << " ";
}

// Function to count the distinct
// element after updating each query
static void updateQuery(int arr[], int n, 
                        int queries[Q][2],
                        int q)
{
  // Store the elements in map
  map<int,int> map;

  store(arr, n, map);

  for (int i = 0; i < q; i++) 
  {
    // Function Call
    Distinct(arr, n, 
             queries[i][0], 
             queries[i][1], map);
  }
}

// Driver Code
int main()
{
  // Given array arr[]
  int arr[] = {2, 2, 5, 
               5, 4, 6, 3};

  int N = sizeof(arr) / 
          sizeof(arr[0]);

  // Given Queries
  int queries[Q][2] = {{1, 7}, 
                       {6, 8}, 
                       {7, 2}};

  // Function Call
  updateQuery(arr, N, queries, Q);
}

// This code is contributed by gauravrajput1

Java

// Java program for the above approach

import java.io.*;
import java.util.*;

class GFG {

    // Function to store the frequency
    // of each element in the Map
    static void store(int arr[], int n,
                      HashMap<Integer,
                              Integer>
                          map)
    {
        for (int i = 0; i < n; i++) {

            // Store the frequency of
            // element arr[i]
            if (!map.containsKey(arr[i]))
                map.put(arr[i], 1);
            else
                map.put(arr[i],
                        map.get(arr[i]) + 1);
        }
    }

    // Function to update an array and
    // map & to find the distinct elements
    static void Distinct(int arr[], int n,
                         int p, int x,
                         HashMap<Integer,
                                 Integer>
                             map)
    {

        // Decrease the element if it
        // was previously present in Map
        map.put(arr[p - 1],
                map.get(arr[p - 1]) - 1);

        if (map.get(arr[p - 1]) == 0)
            map.remove(arr[p - 1]);

        // Add the new element to map
        if (!map.containsKey(x)) {
            map.put(x, 1);
        }
        else {
            map.put(x, map.get(x) + 1);
        }

        // Update the array
        arr[p - 1] = x;

        // Print the count of distinct
        // elements
        System.out.print(map.size() + " ");
    }

    // Function to count the distinct
    // element after updating each query
    static void updateQuery(
        int arr[], int n,
        int queries[][], int q)
    {
        // Store the elements in map
        HashMap<Integer, Integer> map
            = new HashMap<>();

        store(arr, n, map);

        for (int i = 0; i < q; i++) {

            // Function Call
            Distinct(arr, n, queries[i][0],
                     queries[i][1], map);
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        int[] arr = { 2, 2, 5, 5, 4, 6, 3 };

        int N = arr.length;
        int Q = 3;

        // Given Queries
        int queries[][]
            = new int[][] { { 1, 7 },
                            { 6, 8 },
                            { 7, 2 } };

        // Function Call
        updateQuery(arr, N, queries, Q);
    }
}

Python3

# Python3 Program to implement
# the above approach

# Function to store the frequency
# of each element in the Map
def store(arr, n, Map) :
    for i in range(n) :
         
        # Store the frequency of
        # element arr[i]
        if (arr[i] not in Map) :
            Map[arr[i]] = 1
        else :
            Map[arr[i]] += 1
            
# Function to update an array and
# map & to find the distinct elements
def Distinct(arr, n, p, x, Map) :
     
    # Decrease the element if it
    # was previously present in Map
    Map[arr[p - 1]] = Map[arr[p - 1]] - 1
 
    if (Map[arr[p - 1]] == 0) :
        del Map[arr[p - 1]]
 
    # Add the new element to map
    if(x not in Map) :
    
        Map[x] = 1
    
    else :
    
        Map[x] += 1
     
    # Update the array
    arr[p - 1] = x
 
    # Print the count of distinct
    # elements
    print(len(Map), end = " ")
    
# Function to count the distinct
# element after updating each query
def updateQuery(arr, n, queries, q) :
     
    # Store the elements in map
    Map = {}
 
    store(arr, n, Map)
 
    for i in range(q) :
         
        # Function Call
        Distinct(arr, n, queries[i][0], queries[i][1], Map)

# Given array []arr
arr = [ 2, 2, 5, 5, 4, 6, 3 ]

N = len(arr)
Q = 3

# Given queries
queries = [ [ 1, 7 ], [ 6, 8 ], [ 7, 2 ] ]

# Function call
updateQuery(arr, N, queries, Q)

# This code is contributed by divyesh072019.

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to store the frequency
// of each element in the Map
static void store(int []arr, int n,
       Dictionary<int, int>map)
{
    for(int i = 0; i < n; i++) 
    {
        
        // Store the frequency of
        // element arr[i]
        if (!map.ContainsKey(arr[i]))
            map.Add(arr[i], 1);
        else
            map[arr[i]] = map[arr[i]] + 1;
    }
}

// Function to update an array and
// map & to find the distinct elements
static void Distinct(int []arr, int n,
                     int p, int x,
                     Dictionary<int, int>map)
{
    
    // Decrease the element if it
    // was previously present in Map
    map[arr[p - 1]] = map[arr[p - 1]] - 1;

    if (map[arr[p - 1]] == 0)
        map.Remove(arr[p - 1]);

    // Add the new element to map
    if (!map.ContainsKey(x))
    {
        map.Add(x, 1);
    }
    else
    {
        map[x]= map[x] + 1;
    }
    
    // Update the array
    arr[p - 1] = x;

    // Print the count of distinct
    // elements
    Console.Write(map.Count + " ");
}

// Function to count the distinct
// element after updating each query
static void updateQuery(int []arr, int n,
                        int [,]queries, int q)
{
    
    // Store the elements in map
    Dictionary<int, 
               int> map = new Dictionary<int, 
                                         int>();

    store(arr, n, map);

    for(int i = 0; i < q; i++) 
    {
        
        // Function Call
        Distinct(arr, n, queries[i, 0],
                 queries[i, 1], map);
    }
}

// Driver Code
public static void Main(String[] args)
{
    
    // Given array []arr
    int[] arr = { 2, 2, 5, 5, 4, 6, 3 };

    int N = arr.Length;
    int Q = 3;

    // Given queries
    int [,]queries = new int[,]{ { 1, 7 },
                                 { 6, 8 },
                                 { 7, 2 } };

    // Function call
    updateQuery(arr, N, queries, Q);
}
}

// This code is contributed by Amit Katiyar

JavaScript

<script>
// Javascript program for the above approach

// Function to store the frequency
    // of each element in the Map
function store(arr,n,map)
{
    for (let i = 0; i < n; i++) {
 
            // Store the frequency of
            // element arr[i]
            if (!map.has(arr[i]))
                map.set(arr[i], 1);
            else
                map.set(arr[i],
                        map.get(arr[i]) + 1);
        }
}

 // Function to update an array and
    // map & to find the distinct elements
function Distinct(arr,n,p,x,map)
{
    // Decrease the element if it
        // was previously present in Map
        map.set(arr[p - 1],
                map.get(arr[p - 1]) - 1);
 
        if (map.get(arr[p - 1]) == 0)
            map.delete(arr[p - 1]);
 
        // Add the new element to map
        if (!map.has(x)) {
            map.set(x, 1);
        }
        else {
            map.set(x, map.get(x) + 1);
        }
 
        // Update the array
        arr[p - 1] = x;
 
        // Print the count of distinct
        // elements
        document.write(map.size + " ");
}

// Function to count the distinct
    // element after updating each query
function updateQuery(arr,n,queries,q)
{
    // Store the elements in map
        let map
            = new Map();
 
        store(arr, n, map);
 
        for (let i = 0; i < q; i++) {
 
            // Function Call
            Distinct(arr, n, queries[i][0],
                     queries[i][1], map);
        }
}

// Driver Code
let arr=[2, 2, 5, 5, 4, 6, 3];
let  N = arr.length;
let  Q = 3;
let queries=[[ 1, 7 ],[ 6, 8 ],[ 7, 2 ]];
// Function Call
updateQuery(arr, N, queries, Q);

// This code is contributed by patel2127
</script>

Output

6 6 5

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

Count all distinct pairs of repeating elements from the array for every array element

ayush_dragneel

Improve

Article Tags :

Practice Tags :

Queries to print count of distinct array elements after replacing element at index P by a given element

Similar Reads

Thank You!

What kind of Experience do you want to share?