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 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 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
<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>
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 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 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
<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>
Time Complexity: O(N + Q)
Auxiliary Space: O(N)
Similar Reads
Count all distinct pairs of repeating elements from the array for every array element Given an array arr[] of N integers. For each element in the array, the task is to count the possible pairs (i, j), excluding the current element, such that i < j and arr[i] = arr[j]. Examples: Input: arr[] = {1, 1, 2, 1, 2}Output: 2 2 3 2 3Explanation:For index 1, remaining elements after excludi
7 min read
k-th distinct (or non-repeating) element among unique elements in an array. Given an integer array arr[], print kth distinct element in this array. The given array may contain duplicates and the output should print the k-th element among all unique elements. If k is more than the number of distinct elements, print -1.Examples:Input: arr[] = {1, 2, 1, 3, 4, 2}, k = 2Output:
7 min read
Difference of count of distinct elements present to left and right for each array element Given an array arr[] consisting of N integers, the task for each array element is to find the absolute difference between the count of distinct elements to the left and the right of it in the given array arr[]. Examples: Input: arr[] = {7, 7, 3, 2, 3}Output: 2 2 0 1 2Explanation:Count of distinct el
12 min read
Count distinct elements from a range of a sorted sequence from a given frequency array Given two integers L and R and an array arr[] consisting of N positive integers( 1-based indexing ) such that the frequency of ith element of a sorted sequence, say A[], is arr[i]. The task is to find the number of distinct elements from the range [L, R] in the sequence A[]. Examples: Input: arr[] =
13 min read
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times Given an array arr[] consisting of N integers, the task is to find the number of different sequences that can be formed after performing the below operation on the given array arr[] any number of times. Choose two indices i and j such that arr[i] is equal to arr[j] and update all the elements in the
7 min read
Count subarrays having a single distinct element that can be obtained from a given array Given an array arr[] of size N, the task is to count the number of subarrays consisting of a single distinct element that can be obtained from a given array. Examples: Input: N = 4, arr[] = { 2, 2, 2, 2 }Output: 7Explanation: All such subarrays {{2}, {2}, {2}, {2}, {2, 2}, {2, 2, 2}, {2, 2, 2, 2}}.
5 min read