Maximizing Product-Weighted Subsequence Length

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++

// 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;
}

Java

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));
    }
}

Python3

# 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))

C#

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));
    }
}

Javascript

// 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));

Output

2

Time Complexity: O(n*log n)
Auxiliary Space: O(1)