Maximise the size of consecutive element subsets in an array
Last Updated :
17 Oct, 2022
Given an integer array and an integer k. The array elements denote positions of points on a 1-D number line, find the maximum size of the subset of points that can have consecutive values of points which can be formed by placing another k points on the number line. Note that all coordinates should be distinct and elements of the array are in increasing order.
Examples:
Input : arr[] = {1, 2, 3, 4, 10, 11, 14, 15},
k = 4
Output : 8
For maximum size subset, it is optimal to
choose the points on number line at
coordinates 12, 13, 16 and 17, so that the
size of the consecutive valued subset will
become 8 which will be maximum .
Input : arr[] = {7, 8, 12, 13, 15, 18}
k = 5
Output : 10
For maximum size subset, it is optimal to choose
the points on number line at coordinates 9, 10,
11, 14 and 16, so that the size of the consecutive
valued subset will become 10 which will be maximum .
A brute force consists of checking all the possible (l, r) pairs for the condition ((arr[r]-arr[l])-(r-l)) ? k. In order to find out if a pair (l, r) is valid, we should check if the number of points that need to be placed between these two initial ones is not greater than K. Since arr[i] is the coordinate of the i-th point in the input array (arr), then we need to check if (arr[r] – arr[l]) – (r – l ) ? k.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int maximiseSubset( int arr[], int n, int k)
{
int ans = k;
for ( int l = 0; l < n - 1; l++)
for ( int r = l; r < n; r++)
if ((arr[r] - arr[l]) - (r - l) <= k)
ans = max(ans, r - l + k + 1);
return (ans);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 10, 11, 14, 15 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 4;
printf ( "%dn" , maximiseSubset(arr, n, k));
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maximiseSubset( int [] arr, int n, int k)
{
int ans = k;
for ( int l = 0 ; l < n - 1 ; l++)
for ( int r = l; r < n; r++)
if ((arr[r] - arr[l]) - (r - l) <= k)
ans = Math.max(ans, r - l + k + 1 );
return (ans);
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 10 , 11 , 14 , 15 };
int n = arr.length;
int k = 4 ;
System.out.println(maximiseSubset(arr, n, k));
}
}
|
Python3
def maximiseSubset(arr , n, k):
ans = k
for l in range (n - 1 ):
for r in range (l, n):
if ((arr[r] - arr[l]) - (r - l) < = k) :
ans = max (ans, r - l + k + 1 )
return (ans)
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 10 , 11 , 14 , 15 ]
n = len (arr)
k = 4
print (maximiseSubset(arr, n, k))
|
C#
using System;
class GFG
{
static int maximiseSubset( int [] arr,
int n, int k)
{
int ans = k;
for ( int l = 0; l < n - 1; l++)
for ( int r = l; r < n; r++)
if ((arr[r] - arr[l]) -
(r - l) <= k)
ans = Math.Max(ans, r - l +
k + 1);
return (ans);
}
public static void Main()
{
int [] arr = {1, 2, 3, 4,
10, 11, 14, 15};
int n = arr.Length;
int k = 4;
Console.WriteLine(maximiseSubset(arr, n, k));
}
}
|
PHP
<?php
function maximiseSubset( $arr , $n , $k )
{
$ans = $k ;
for ( $l = 0; $l < $n - 1; $l ++)
for ( $r = $l ; $r < $n ; $r ++)
if (( $arr [ $r ] - $arr [ $l ]) -
( $r - $l ) <= $k )
$ans = max( $ans , $r - $l + $k + 1);
return ( $ans );
}
$arr = array (1, 2, 3, 4, 10, 11, 14, 15 );
$n = sizeof( $arr );
$k = 4;
echo (maximiseSubset( $arr , $n , $k ));
?>
|
Javascript
<script>
function maximiseSubset(arr, n, k)
{
let ans = k;
for (let l = 0; l < n - 1; l++)
for (let r = l; r < n; r++)
if ((arr[r] - arr[l]) - (r - l) <= k)
ans = Math.max(ans, r - l + k + 1);
return (ans);
}
let arr = [ 1, 2, 3, 4, 10, 11, 14, 15 ];
let n = arr.length;
let k = 4;
document.write(maximiseSubset(arr, n, k));
</script>
|
Time complexity: O(N2).
Auxiliary Space: O(1)
Efficient Approach:
In order to optimize the brute force, notice that if r increases, then l also increases (or at least stays the same). We can maintain two indexes. Initialize l and r both as 0. Then we start incrementing r. As we do this, at each step we increment l until the condition used in the brute force approach becomes true. When r reaches the last index, we stop.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int maximiseSubset( int arr[], int n, int k)
{
int ans = k;
int l = 0, r = 0;
while (r < n) {
while ((arr[r] - arr[l]) - (r - l) > k)
l++;
ans = max(ans, r - l + k + 1);
r++;
}
return (ans);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 10, 11, 14, 15 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 4;
printf ( "%d" , maximiseSubset(arr, n, k));
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maximiseSubset( int [] arr, int n, int k)
{
int ans = k;
int l = 0 , r = 0 ;
while (r < n) {
while ((arr[r] - arr[l]) - (r - l) > k)
l++;
ans = Math.max(ans, r - l + k + 1 );
r++;
}
return (ans);
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 10 , 11 , 14 , 15 };
int n = arr.length;
int k = 4 ;
System.out.println(maximiseSubset(arr, n, k));
}
}
|
Python3
def maximiseSubset(arr, n, k):
ans = k;
l = 0 ; r = 0 ;
while (r < n):
while ((arr[r] - arr[l]) - (r - l) > k):
l = l + 1 ;
ans = max (ans, r - l + k + 1 );
r = r + 1 ;
return (ans);
arr = [ 1 , 2 , 3 , 4 , 10 , 11 , 14 , 15 ];
n = len (arr);
k = 4 ;
print (maximiseSubset(arr, n, k));
|
C#
using System;
class GFG
{
static int maximiseSubset( int [] arr,
int n, int k)
{
int ans = k;
int l = 0, r = 0;
while (r < n)
{
while ((arr[r] - arr[l]) -
(r - l) > k)
l++;
ans = Math.Max(ans, r - l +
k + 1);
r++;
}
return (ans);
}
public static void Main()
{
int [] arr = {1, 2, 3, 4,
10, 11, 14, 15};
int n = arr.Length;
int k = 4;
Console.WriteLine(maximiseSubset(arr, n, k));
}
}
|
PHP
<?php
function maximiseSubset( $arr , $n , $k )
{
$ans = $k ;
$l = 0; $r = 0;
while ( $r < $n )
{
while (( $arr [ $r ] - $arr [ $l ]) -
( $r - $l ) > $k )
$l ++;
$ans = max( $ans , $r - $l + $k + 1);
$r ++;
}
return ( $ans );
}
$arr = array (1, 2, 3, 4, 10, 11, 14, 15 );
$n = sizeof( $arr );
$k = 4;
echo (maximiseSubset( $arr , $n , $k ));
?>
|
Javascript
<script>
function maximiseSubset(arr,n,k)
{
let ans = k;
let l = 0, r = 0;
while (r < n) {
while ((arr[r] - arr[l]) - (r - l) > k)
l++;
ans = Math.max(ans, r - l + k + 1);
r++;
}
return (ans);
}
let arr=[1, 2, 3, 4, 10, 11, 14, 15 ];
let n = arr.length;
let k = 4;
document.write(maximiseSubset(arr, n, k));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...