Subsequence pair from given Array having all unique and all same elements respectively
Last Updated :
25 May, 2021
Given an array arr[] of N integers, the task is to choose the two subsequences of equal lengths such that the first subsequence must have all the unique elements and the second subsequence must have all the same elements. Print the maximum length of the subsequence pair.
Examples:
Input: arr[] = {1, 2, 3, 1, 2, 3, 3, 3}
Output: 3
Explanation:
The first subsequence consists of elements {1, 2, 3}.
The second subsequence consists of elements {3, 3, 3}.
Input: arr[] = {2, 2, 2, 3}
Output: 2
Explanation:
The first subsequence consists of elements {2, 3}.
The second subsequence consists of elements {2, 2}.
Approach:
- Count the maximum frequency(say f) of the element in the given array.
- Count the distinct elements(say d) present in the array.
- To make both the subsequence of equal length with the given property, then the size of the first subsequence cannot exceed d, and the size of the second subsequence cannot exceed f.
- The maximum value of the subsequence is given on the basis of two cases below:
- The subsequence with distinct elements must have an element with maximum frequency. Therefore, the minimum of (d, f – 1) is the possible length of a subsequence with the given property.
- If the length of a subsequence with a distinct element is greater than maximum frequency, then, the minimum of (d – 1, f) is the possible length of a subsequence with the given property.
- The maximum value in the above two cases is the maximum length of a subsequence with the given property.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumSubsequence( int arr[], int N)
{
unordered_map< int , int > M;
for ( int i = 0; i < N; i++) {
M[arr[i]]++;
}
int distinct_size = M.size();
int maxFreq = 1;
for ( auto & it : M) {
maxFreq = max(maxFreq, it.second);
}
cout << max(min(distinct_size, maxFreq - 1),
min(distinct_size - 1, maxFreq));
}
int main()
{
int arr[] = { 1, 2, 3, 4, 4, 4, 4, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
maximumSubsequence(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void maximumSubsequence( int arr[], int N)
{
HashMap<Integer,
Integer> M = new HashMap<Integer,
Integer>();
for ( int i = 0 ; i < N; i++)
{
if (M.containsKey(arr[i]))
{
M.put(arr[i], M.get(arr[i]) + 1 );
}
else
{
M.put(arr[i], 1 );
}
}
int distinct_size = M.size();
int maxFreq = 1 ;
for (Map.Entry<Integer, Integer> it : M.entrySet())
{
maxFreq = Math.max(maxFreq, it.getValue());
}
System.out.print(Math.max(
Math.min(distinct_size, maxFreq - 1 ),
Math.min(distinct_size - 1 , maxFreq)));
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 4 , 4 , 4 , 4 , 5 };
int N = arr.length;
maximumSubsequence(arr, N);
}
}
|
Python3
def maximumSubsequence(arr, N):
M = {i : 0 for i in range ( 100 )}
for i in range (N):
M[arr[i]] + = 1
distinct_size = len (M)
maxFreq = 1
for value in M.values():
maxFreq = max (maxFreq, value)
print ( max ( min (distinct_size, maxFreq - 1 ),
min (distinct_size - 1 , maxFreq)))
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 4 , 4 , 4 , 5 ]
N = len (arr)
maximumSubsequence(arr, N)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void maximumSubsequence( int []arr, int N)
{
Dictionary< int ,
int > M = new Dictionary< int ,
int >();
for ( int i = 0; i < N; i++)
{
if (M.ContainsKey(arr[i]))
{
M[arr[i]] = M[arr[i]] + 1;
}
else
{
M.Add(arr[i], 1);
}
}
int distinct_size = M.Count;
int maxFreq = 1;
foreach (KeyValuePair< int , int > m in M)
{
maxFreq = Math.Max(maxFreq, m.Value);
}
Console.Write(Math.Max(
Math.Min(distinct_size, maxFreq - 1),
Math.Min(distinct_size - 1, maxFreq)));
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 4, 4, 4, 4, 5 };
int N = arr.Length;
maximumSubsequence(arr, N);
}
}
|
Javascript
<script>
function maximumSubsequence(arr, N) {
let M = new Map();
for (let i = 0; i < N; i++) {
if (M.has(arr[i])) {
M.set(arr[i], M.get(arr[i]) + 1);
}
else {
M.set(arr[i], 1);
}
}
let distinct_size = M.size;
let maxFreq = 1;
for (let it of M) {
maxFreq = Math.max(maxFreq, it[1]);
}
document.write(Math.max(Math.min(distinct_size, maxFreq - 1), Math.min(distinct_size - 1, maxFreq)));
}
let arr = [1, 2, 3, 4, 4, 4, 4, 4, 5];
let N = arr.length;
maximumSubsequence(arr, N);
</script>
|
Time Complexity: O(N), where N is the number of elements in the array.
Auxiliary Space Complexity: O(N), where N is the number of elements in the array.
Share your thoughts in the comments
Please Login to comment...