Given an array arr[] of size N, you have to find the length of the longest subsequence such that the product of the elements in the subsequence divided by the factorial of its length is maximized.
Examples:
Input: N = 5, arr[] = {1, 2, 4, 5, 2}
Output: 2
Explanation: We can choose 4 and 5 giving an answer of (4*5)/(2!) = 10, which is the maximum possible.Input: N = 3, arr[] = {1, 3, 2}
Output: 2
Explanation: We can have a subsequence with elements 3 and 2 to obtain the maximum possible answer of 3.
Approach: This can be solved with the following idea;
The main idea is to sort the array in ascending order and then iteratively(from largest to smallest elements) construct a subsequence and check if the size of the subsequence is greater than ith element which means if we include this element in subsequence then overall result will be reduced hence break the loop here and return the length of subsequence.
Below are the steps involved:
- Sort the input array arr in ascending order.
- Initialize two variables: ind to keep track of the length of subsequence while traversing the sorted array, and ans to store the length of the longest subsequence.
- Start iterating through the sorted array from the end (largest elements).
- Check if the current element at index i is greater than or equal to the value of ind. If it is, it means that this element can be part of the subsequence. Increment ans to indicate the inclusion of this element in the subsequence.
- If the current element is not greater than or equal to ind, break out of the loop as there is no need to continue checking further. We’ve already found the longest subsequence based on the problem’s criteria.
- Return the value of ans as the length of the longest subsequence.
Below is the implementation of the code:
// C++ Implementation #include <bits/stdc++.h> #include <iostream> using namespace std;
// Function to find longest subsequence int longestSubsequenceLength( int n, vector< int >& arr)
{ // Sort the array
sort(arr.begin(), arr.end());
int ans = 0;
int index = 1;
// Start iterating from backwards
for ( int i = n - 1; i >= 0; i--) {
// If index value is less than value
// of element
if (index <= arr[i]) {
// Increment in ans
index++;
ans++;
}
else {
break ;
}
}
// Return the length of longest
return ans;
} // Driver code int main()
{ int n = 4;
vector< int > arr = { 2, 4, 5, 1 };
// Function call
cout << longestSubsequenceLength(n, arr);
return 0;
} |
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class LongestSubsequence {
// Function to find longest subsequence
static int longestSubsequenceLength( int n, List<Integer> arr) {
// Sort the array
Collections.sort(arr);
int ans = 0 ;
int index = 1 ;
// Start iterating from backwards
for ( int i = n - 1 ; i >= 0 ; i--) {
// If index value is less than value
// of element
if (index <= arr.get(i)) {
// Increment in ans
index++;
ans++;
} else {
break ;
}
}
// Return the length of the longest subsequence
return ans;
}
// Driver code
public static void main(String[] args) {
int n = 4 ;
List<Integer> arr = Arrays.asList( 2 , 4 , 5 , 1 );
// Function call
System.out.println(longestSubsequenceLength(n, arr));
}
} |
# Python code to implement above code # Function to find longest subsequence length def longest_subsequence_length(n, arr):
# Sort the array
arr.sort()
ans = 0
index = 1
# Start iterating from backwards
for i in range (n - 1 , - 1 , - 1 ):
# If index value is less than value of element
if index < = arr[i]:
# Increment in ans and index
index + = 1
ans + = 1
else :
break
# Return the length of the longest subsequence
return ans
# Driver code n = 4
arr = [ 2 , 4 , 5 , 1 ]
# Function call print (longest_subsequence_length(n, arr))
|
using System;
using System.Collections.Generic;
using System.Linq;
public class LongestSubsequence {
// Function to find the longest subsequence
static int LongestSubsequenceLength( int n,
List< int > arr)
{
// Sort the list
arr.Sort();
int ans = 0;
int index = 1;
// Start iterating from backwards
for ( int i = n - 1; i >= 0; i--) {
// If index value is less than the value
// of the element
if (index <= arr[i]) {
// Increment in ans
index++;
ans++;
}
else {
break ;
}
}
// Return the length of the longest subsequence
return ans;
}
// Driver code
public static void Main( string [] args)
{
int n = 4;
List< int > arr = new List< int >{ 2, 4, 5, 1 };
// Function call
Console.WriteLine(LongestSubsequenceLength(n, arr));
}
} |
// Function to find longest subsequence function longestSubsequenceLength(n, arr) {
// Sort the array
arr.sort((a, b) => a - b);
let ans = 0;
let index = 1;
// Start iterating from backwards
for (let i = n - 1; i >= 0; i--) {
// If index value is less than
// value of element
if (index <= arr[i]) {
// Increment in ans
index++;
ans++;
} else {
break ;
}
}
// Return the length of
// longest subsequence
return ans;
} // Driver code let n = 4; let arr = [2, 4, 5, 1]; // Function call console.log(longestSubsequenceLength(n, arr)); |
2
Time Complexity: O(n*log n)
Auxiliary Space: O(1)