Maximum count number of valley elements in a subarray of size K
Given an array arr[], the task is to choose a subarray of size K which contains the maximum number of valley points with respect to adjacent elements.
An element arr[i] is known as a valley point, if both of its adjacent elements are greater than it, i.e. and .
Examples:
Input: arr[] = {5, 4, 6, 4, 5, 2, 3, 1}, K = 7 the
Output: 3
Explanation:
In subarray arr[0-6] = {5, 4, 6, 4, 5, 2, 3}
There are 3 Valley points in the subarray, which is maximum.
Input: arr[] = {2, 1, 4, 2, 3, 4, 1, 2}, K = 4
Output: 1
Explanation:
In subarray arr[0-3] = {2, 1, 4, 2}
There is only one valley point in the subarray, which is the maximum.
Approach: The idea is to use the sliding window technique to solve this problem.
Below is an illustration of the steps of the approach:
- Find the total count of valley points in the first sub-array of size K.
- Iterate for all the starting points of the possible subarrays, that is N-K points of the array, and apply the inclusion and exclusion principle to compute the number of valley points in the current window.
- At each step, update the final answer to compute the global maximum of every subarray.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
void minpoint( int arr[], int n, int k)
{
int min_point = 0;
for ( int i = 1; i < k-1 ; i++)
{
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1])
min_point += 1;
}
int final_point = min_point;
for ( int i = k ; i < n; i++)
{
if (arr[i - ( k - 1 )] < arr[i - ( k - 1 ) + 1]&&
arr[i - ( k - 1 )] < arr[i - ( k - 1 ) - 1])
min_point -= 1;
if (arr[i - 1] < arr[i] && arr[i - 1] < arr[i - 2])
min_point += 1;
if (min_point > final_point)
final_point = min_point;
}
cout<<(final_point);
}
int main()
{
int arr[] = {2, 1, 4, 2, 3, 4, 1, 2};
int n = sizeof (arr)/ sizeof (arr[0]);
int k = 4;
minpoint(arr, n, k);
return 0;
}
|
Java
class GFG{
static void minpoint( int arr[], int n, int k)
{
int min_point = 0 ;
for ( int i = 1 ; i < k - 1 ; i++)
{
if (arr[i] < arr[i - 1 ] &&
arr[i] < arr[i + 1 ])
min_point += 1 ;
}
int final_point = min_point;
for ( int i = k ; i < n; i++)
{
if (arr[i - ( k - 1 )] < arr[i - ( k - 1 ) + 1 ] &&
arr[i - ( k - 1 )] < arr[i - ( k - 1 ) - 1 ])
min_point -= 1 ;
if (arr[i - 1 ] < arr[i] &&
arr[i - 1 ] < arr[i - 2 ])
min_point += 1 ;
if (min_point > final_point)
final_point = min_point;
}
System.out.println(final_point);
}
public static void main (String[] args)
{
int arr[] = { 2 , 1 , 4 , 2 , 3 , 4 , 1 , 2 };
int n = arr.length;
int k = 4 ;
minpoint(arr, n, k);
}
}
|
Python3
def minpoint(arr, n, k):
min_point = 0
for i in range ( 1 , k - 1 ):
if (arr[i] < arr[i - 1 ] and arr[i] < arr[i + 1 ]):
min_point + = 1
final_point = min_point
for i in range (k, n):
if (arr[i - ( k - 1 )] < arr[i - ( k - 1 ) + 1 ] and \
arr[i - ( k - 1 )] < arr[i - ( k - 1 ) - 1 ]):
min_point - = 1
if (arr[i - 1 ] < arr[i] and arr[i - 1 ] < arr[i - 2 ]):
min_point + = 1
if (min_point > final_point):
final_point = min_point
print (final_point)
if __name__ = = "__main__" :
arr = [ 2 , 1 , 4 , 2 , 3 , 4 , 1 , 2 ]
n = len (arr)
k = 4
minpoint(arr, n, k)
|
C#
using System;
class GFG{
static void minpoint( int []arr, int n, int k)
{
int min_point = 0;
for ( int i = 1; i < k - 1; i++)
{
if (arr[i] < arr[i - 1] &&
arr[i] < arr[i + 1])
min_point += 1;
}
int final_point = min_point;
for ( int i = k ; i < n; i++)
{
if (arr[i - ( k - 1 )] < arr[i - ( k - 1 ) + 1] &&
arr[i - ( k - 1 )] < arr[i - ( k - 1 ) - 1])
min_point -= 1;
if (arr[i - 1] < arr[i] &&
arr[i - 1] < arr[i - 2])
min_point += 1;
if (min_point > final_point)
final_point = min_point;
}
Console.WriteLine(final_point);
}
public static void Main ( string [] args)
{
int []arr = { 2, 1, 4, 2, 3, 4, 1, 2 };
int n = arr.Length;
int k = 4;
minpoint(arr, n, k);
}
}
|
Javascript
<script>
function minpoint(arr, n, k) {
let min_point = 0;
for (let i = 1; i < k - 1; i++) {
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1])
min_point += 1;
}
let final_point = min_point;
for (let i = k; i < n; i++) {
if (arr[i - (k - 1)] < arr[i - (k - 1) + 1] &&
arr[i - (k - 1)] < arr[i - (k - 1) - 1])
min_point -= 1;
if (arr[i - 1] < arr[i] && arr[i - 1] < arr[i - 2])
min_point += 1;
if (min_point > final_point)
final_point = min_point;
}
document.write(final_point);
}
let arr = [2, 1, 4, 2, 3, 4, 1, 2];
let n = arr.length;
let k = 4;
minpoint(arr, n, k);
</script>
|
Time Complexity: O(N)
Space Complexity: O(1)
Last Updated :
08 May, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...