Longest subsequence whose average is less than K
Last Updated :
30 Aug, 2022
Given an array of N positive integers and Q queries consisting of an integer K, the task is to print the length of the longest subsequence whose average is less than K.
Examples:
Input: a[] = {1, 3, 2, 5, 4}
Query1: K = 3
Query2: K = 5
Output:
4
5
Query1: The subsequence is: {1, 3, 2, 4} or {1, 3, 2, 5}
Query2: The subsequence is: {1, 3, 2, 5, 4}
A Naive Approach is to generate all subsequences using power-set and check for the longest subsequence whose average is less than K.
Time Complexity: O(2N * N )
An efficient approach is to sort the array elements and find the average of elements starting from the left. Insert the average of elements computed from the left into the container(vector or arrays). Sort the container’s element and then use binary search to search for the number K in the container. The length of the longest subsequence will thus be the index number which upper_bound() returns for every query.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
int longestSubsequence( int a[], int n, int q[], int m)
{
sort(a, a + n);
int sum = 0;
int b[n];
for ( int i = 0; i < n; i++) {
sum += a[i];
double av = ( double )(sum) / ( double )(i + 1);
b[i] = (( int )(av + 1));
}
sort(b, b + n);
for ( int i = 0; i < m; i++) {
int k = q[i];
int longest = upper_bound(b, b + n, k) - b;
cout << "Answer to Query" << i + 1 << ": "
<< longest << endl;
}
}
int main()
{
int a[] = { 1, 3, 2, 5, 4 };
int n = sizeof (a) / sizeof (a[0]);
int q[] = { 4, 2, 1, 5 };
int m = sizeof (q) / sizeof (q[0]);
longestSubsequence(a, n, q, m);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static void longestSubsequence( int a[], int n,
int q[], int m)
{
Arrays.sort(a);
int sum = 0 ;
int []b = new int [n];
for ( int i = 0 ; i < n; i++)
{
sum += a[i];
double av = ( double )(sum) / ( double )(i + 1 );
b[i] = (( int )(av + 1 ));
}
Arrays.sort(b);
for ( int i = 0 ; i < m; i++)
{
int k = q[i];
int longest = upperBound(b, 0 , n, k);
System.out.println( "Answer to Query" + (i + 1 ) + ": "
+ longest);
}
}
private static int upperBound( int [] a, int low, int high, int element)
{
while (low < high)
{
int middle = low + (high - low)/ 2 ;
if (a[middle] > element)
high = middle;
else
low = middle + 1 ;
}
return low;
}
public static void main(String[] args)
{
int a[] = { 1 , 3 , 2 , 5 , 4 };
int n = a.length;
int q[] = { 4 , 2 , 1 , 5 };
int m = q.length;
longestSubsequence(a, n, q, m);
}
}
|
Python3
import bisect
def longestSubsequence(a, n, q, m):
a.sort()
Sum = 0
b = [ None ] * n
for i in range ( 0 , n):
Sum + = a[i]
av = Sum / / (i + 1 )
b[i] = av + 1
b.sort()
for i in range ( 0 , m):
k = q[i]
longest = bisect.bisect_right(b, k)
print ( "Answer to Query" , i + 1 , ":" , longest)
if __name__ = = "__main__" :
a = [ 1 , 3 , 2 , 5 , 4 ]
n = len (a)
q = [ 4 , 2 , 1 , 5 ]
m = len (q)
longestSubsequence(a, n, q, m)
|
C#
using System;
class GFG
{
static void longestSubsequence( int []a, int n,
int []q, int m)
{
Array.Sort(a);
int sum = 0;
int []b = new int [n];
for ( int i = 0; i < n; i++)
{
sum += a[i];
double av = ( double )(sum) / ( double )(i + 1);
b[i] = (( int )(av + 1));
}
Array.Sort(b);
for ( int i = 0; i < m; i++)
{
int k = q[i];
int longest = upperBound(b,0, n, k);
Console.WriteLine( "Answer to Query" + (i + 1) + ": "
+ longest);
}
}
private static int upperBound( int [] a, int low,
int high, int element)
{
while (low < high)
{
int middle = low + (high - low)/2;
if (a[middle] > element)
high = middle;
else
low = middle + 1;
}
return low;
}
static public void Main ()
{
int []a = { 1, 3, 2, 5, 4 };
int n = a.Length;
int []q = { 4, 2, 1, 5 };
int m = q.Length;
longestSubsequence(a, n, q, m);
}
}
|
Javascript
<script>
function longestSubsequence(a, n, q, m)
{
a.sort( function (a, b){ return a - b});
let sum = 0;
let b = new Array(n);
for (let i = 0; i < n; i++)
{
sum += a[i];
let av = parseInt((sum) / (i + 1), 10);
b[i] = (av + 1);
}
b.sort( function (a, b){ return a - b});
for (let i = 0; i < m; i++)
{
let k = q[i];
let longest = upperBound(b,0, n, k);
document.write( "Answer to Query" +
(i + 1) + ": "
+ longest + "</br>" );
}
}
function upperBound(a, low, high, element)
{
while (low < high)
{
let middle = low +
parseInt((high - low)/2, 10);
if (a[middle] > element)
high = middle;
else
low = middle + 1;
}
return low;
}
let a = [ 1, 3, 2, 5, 4 ];
let n = a.length;
let q = [ 4, 2, 1, 5 ];
let m = q.length;
longestSubsequence(a, n, q, m);
</script>
|
Output
Answer to Query1: 5
Answer to Query2: 2
Answer to Query3: 0
Answer to Query4: 5
Complexity Analysis:
- Time Complexity: O(N*log N + M*log N)
- Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...