Count of subarrays whose maximum element is greater than k
Last Updated :
19 Sep, 2023
Given an array of n elements and an integer k. The task is to find the count of the subarray which has a maximum element greater than K.
Examples :
Input : arr[] = {1, 2, 3} and k = 2.
Output : 3
All the possible subarrays of arr[] are
{ 1 }, { 2 }, { 3 }, { 1, 2 }, { 2, 3 },
{ 1, 2, 3 }.
Their maximum elements are 1, 2, 3, 2, 3, 3.
There are only 3 maximum elements > 2.
Approach 1: Counting Subarrays having max element <= K and then subtracting from total subarrays.
The idea is to approach problem by counting subarrays whose maximum element is less than or equal to k as counting such subarrays is easier. To find the number of subarray whose maximum element is less than or equal to k, remove all the element which is greater than K and find the number of subarray with the left elements.
Once we find above count, we can subtract it from n*(n+1)/2 to get our required result. Observe, there can be n*(n+1)/2 possible number of subarray of any array of size n. So, finding the number of subarray whose maximum element is less than or equal to K and subtracting it from n*(n+1)/2 gets us the answer.
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countSubarray( int arr[], int n, int k)
{
int s = 0;
int i = 0;
while (i < n) {
if (arr[i] > k) {
i++;
continue ;
}
int count = 0;
while (i < n && arr[i] <= k) {
i++;
count++;
}
s += ((count * (count + 1)) / 2);
}
return (n * (n + 1) / 2 - s);
}
int main()
{
int arr[] = { 1, 2, 3 };
int k = 2;
int n = sizeof (arr) / sizeof (arr[0]);
cout << countSubarray(arr, n, k);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int countSubarray( int arr[], int n, int k)
{
int s = 0 ;
int i = 0 ;
while (i < n) {
if (arr[i] > k) {
i++;
continue ;
}
int count = 0 ;
while (i < n && arr[i] <= k) {
i++;
count++;
}
s += ((count * (count + 1 )) / 2 );
}
return (n * (n + 1 ) / 2 - s);
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 };
int k = 2 ;
int n = arr.length;
System.out.print(countSubarray(arr, n, k));
}
}
|
Python3
def countSubarray(arr, n, k):
s = 0
i = 0
while (i < n):
if (arr[i] > k):
i = i + 1
continue
count = 0
while (i < n and arr[i] < = k):
i = i + 1
count = count + 1
s = s + ((count * (count + 1 )) / / 2 )
return (n * (n + 1 ) / / 2 - s)
arr = [ 1 , 2 , 3 ]
k = 2
n = len (arr)
print (countSubarray(arr, n, k))
|
C#
using System;
class GFG {
static int countSubarray( int [] arr, int n, int k)
{
int s = 0;
int i = 0;
while (i < n) {
if (arr[i] > k) {
i++;
continue ;
}
int count = 0;
while (i < n && arr[i] <= k) {
i++;
count++;
}
s += ((count * (count + 1)) / 2);
}
return (n * (n + 1) / 2 - s);
}
public static void Main()
{
int [] arr = {1, 2, 3};
int k = 2;
int n = arr.Length;
Console.WriteLine(countSubarray(arr, n, k));
}
}
|
Javascript
<script>
function countSubarray(arr, n, k)
{
let s = 0;
let i = 0;
while (i < n) {
if (arr[i] > k) {
i++;
continue ;
}
let count = 0;
while (i < n && arr[i] <= k) {
i++;
count++;
}
s += parseInt((count * (count + 1)) / 2, 10);
}
return (n * parseInt((n + 1) / 2, 10) - s);
}
let arr = [1, 2, 3];
let k = 2;
let n = arr.length;
document.write(countSubarray(arr, n, k));
</script>
|
PHP
<?php
function countSubarray( $arr , $n , $k )
{
$s = 0;
$i = 0;
while ( $i < $n ) {
if ( $arr [ $i ] > $k ) {
$i ++;
continue ;
}
$count = 0;
while ( $i < $n and $arr [ $i ] <= $k ) {
$i ++;
$count ++;
}
$s += (( $count * ( $count + 1)) / 2);
}
return ( $n * ( $n + 1) / 2 - $s );
}
$arr = array ( 1, 2, 3 );
$k = 2;
$n = count ( $arr );
echo countSubarray( $arr , $n , $k );
?>
|
Time Complexity: O(n).
Auxiliary Space: O(1)
Approach 2: Counting Subarrays having max element > K
In this approach we just simply find the count of subarrays that can be formed by including an element at index i which is greater than K. Therefore, if suppose arr [ i ] > K then all the subarrays in which this element is present will have a value which is greater than k, so we just calculate all of these subarrays for every element that is greater than K and add them in answer. We first initialize two variables ans = 0 this contains answer and prev = -1 this keeps track of index of previous element that was greater than K.
To do this we just need three values for every arr [ i ] > K .
- Number of subarrays starting from the index i. This will be ( N – i ) . NOTE: In this we have included the subarray containing single element that is this element itself. { arr [ i ] }
- Number of subarrays ending at this index i but starting index of these subarrays is after the index prev of previous element that was greater than K, why do we do this? Because for that elements we must have already calculated our answer so we dont want to count same subarrays more than once. So, this value will be comes to be ( i – prev – 1 ) . NOTE: In this we subtract 1 because we have already counted a subarray { arr [ i ] } having itself as single element. See above point note.
- Number of subarrays having starting index less than i but greater than prev , and ending index greater than i. Therefore all subarrays in which arr[i] is in between. This we can calculate by multiplying above two values. Lets say them as L = ( N – i – 1 ) and R = ( i – prev -1 ). Now we just multiply these L and R because for every 1 index on left side of i there are R index that can make different subarrays basic maths thing. So, this becomes L * R . Notice here in val of L we have actually subtracted 1 if we dont do this then we include index i in our L*R which will mean we have included number 1 type subarrays again. See point 1.
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
long long countSubarray( int arr[], int n, int k)
{
long long ans = 0 ;
int prev = - 1;
for ( int i = 0 ; i < n ; i++ ) {
if ( arr [ i ] > k ) {
ans += n - i ;
ans += i - prev - 1 ;
ans += ( n - i - 1 ) * 1LL * ( i - prev - 1 ) ;
prev = i;
}
}
return ans;
}
int main()
{
int arr[] = { 4, 5, 1, 2, 3 };
int k = 2;
int n = sizeof (arr) / sizeof (arr[0]);
cout << countSubarray(arr, n, k);
return 0;
}
|
Java
import java.util.*;
public class GFG {
static long countSubarray( int arr[], int n, int k)
{
long ans = 0 ;
int prev = - 1 ;
for ( int i = 0 ; i < n ; i++ ) {
if ( arr [ i ] > k ) {
ans += n - i ;
ans += i - prev - 1 ;
ans += ( n - i - 1 ) * 1L * ( i - prev - 1 ) ;
prev = i;
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 4 , 5 , 1 , 2 , 3 };
int k = 2 ;
int n = arr.length;
System.out.print(countSubarray(arr, n, k));
}
}
|
Python3
def countSubarray( arr, n, k):
ans = 0 ;
prev = - 1 ;
for i in range ( 0 ,n):
if ( arr [ i ] > k ) :
ans + = n - i ;
ans + = i - prev - 1 ;
ans + = ( n - i - 1 ) * ( i - prev - 1 ) ;
prev = i;
return ans;
arr = [ 4 , 5 , 1 , 2 , 3 ];
k = 2 ;
n = len (arr);
print (countSubarray(arr, n, k));
|
C#
using System;
public class GFG {
static long countSubarray( int [] arr, int n, int k)
{
long ans = 0;
int prev = -1;
for ( int i = 0; i < n; i++) {
if (arr[i] > k) {
ans += n - i;
ans += i - prev
- 1;
ans += (n - i - 1) * ( long )1
* (i - prev
- 1);
prev = i;
}
}
return ans;
}
public static void Main( string [] args)
{
int [] arr = { 4, 5, 1, 2, 3 };
int k = 2;
int n = arr.Length;
Console.Write(countSubarray(arr, n, k));
}
}
|
Javascript
function countSubarray(arr, n, k)
{
let ans = 0 ;
let prev = - 1;
for (let i = 0 ; i < n ; i++ ) {
if ( arr [ i ] > k ) {
ans += n - i ;
ans += i - prev - 1 ;
ans += ( n - i - 1 ) * 1 * ( i - prev - 1 ) ;
prev = i;
}
}
return ans;
}
let arr = [ 4, 5, 1, 2, 3 ];
let k = 2;
let n = arr.length;
document.write(countSubarray(arr, n, k));
|
Time Complexity: O(n).
Approach 3 : Sliding Window Technique.
Algorithm:
1. Initialize a variable ans = 0 , a varialble maxElement = 0 and a variable count = 0 .
2. Iterate through the array, doing the following for each element:
a. If the current element i.e. arr[ i ] is greater than current maximum , update the maximum i.e. maxElement = arr[ i ] and reset the count to 0.
b. If the current element is less than or eual to the current maximum, then increment the count.
c. If maxElement is grteater than k, then add count of subarrays to final answer and update the maxElement to current element.
3. Return Final answer.
Here’s the the implementation of Sliding window technique.
C++
#include <bits/stdc++.h>
using namespace std;
int countSubarray( int arr[], int n, int k) {
int maxElement = 0, count = 0, ans = 0;
for ( int i=0; i<n; i++) {
if (arr[i] > maxElement) {
maxElement = arr[i];
count = 0;
}
else {
count++;
}
if (maxElement > k) {
ans += (i - count + 1);
maxElement = arr[i];
count = 0;
}
}
return ans;
}
int main()
{
int arr[] = {1, 2, 3, 4};
int k = 1;
int n = sizeof (arr) / sizeof (arr[0]);
cout << countSubarray(arr, n, k);
return 0;
}
|
C
#include <stdio.h>
int countSubarray( int arr[], int n, int k) {
int maxElement = 0, count = 0, ans = 0;
for ( int i=0; i<n; i++) {
if (arr[i] > maxElement) {
maxElement = arr[i];
count = 0;
}
else {
count++;
}
if (maxElement > k) {
ans += (i - count + 1);
maxElement = arr[i];
count = 0;
}
}
ans += (count * (count + 1)) / 2;
return ans;
}
int main() {
int arr[] = {1, 2, 3, 4};
int k = 1;
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "%d\n" , countSubarray(arr, n, k));
return 0;
}
|
Java
import java.util.*;
public class GFG {
public static int countSubarray( int [] arr, int n, int k) {
int maxElement = 0 ;
int count = 0 ;
int ans = 0 ;
for ( int i = 0 ; i < n; i++) {
if (arr[i] > maxElement) {
maxElement = arr[i];
count = 0 ;
} else {
count++;
}
if (maxElement > k) {
ans += (i - count + 1 );
maxElement = arr[i];
count = 0 ;
}
}
return ans;
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 4 };
int k = 1 ;
int n = arr.length;
int result = countSubarray(arr, n, k);
System.out.println(result);
}
}
|
Python3
def countSubarray(arr, n, k):
maxElement, count, ans = 0 , 0 , 0
for i in range (n):
if arr[i] > maxElement:
maxElement = arr[i]
count = 0
else :
count + = 1
if maxElement > k:
ans + = (i - count + 1 )
maxElement = arr[i]
count = 0
ans + = (count * (count + 1 )) / / 2
return ans
arr = [ 1 , 2 , 3 , 4 ]
k = 1
n = len (arr)
print (countSubarray(arr, n, k))
|
C#
using System;
public class Program {
public static int CountSubarray( int [] arr, int n, int k) {
int maxElement = 0, count = 0, ans = 0;
for ( int i=0; i<n; i++) {
if (arr[i] > maxElement) {
maxElement = arr[i];
count = 0;
}
else {
count++;
}
if (maxElement > k) {
ans += (i - count + 1);
maxElement = arr[i];
count = 0;
}
}
ans += (count * (count + 1)) / 2;
return ans;
}
public static void Main() {
int [] arr = {1, 2, 3, 4};
int k = 1;
int n = arr.Length;
Console.WriteLine(CountSubarray(arr, n, k));
}
}
|
Javascript
function countSubarray(arr, n, k) {
let maxElement = 0, count = 0, ans = 0;
for (let i=0; i<n; i++) {
if (arr[i] > maxElement) {
maxElement = arr[i];
count = 0;
}
else {
count++;
}
if (maxElement > k) {
ans += (i - count + 1);
maxElement = arr[i];
count = 0;
}
}
ans += (count * (count + 1)) / 2;
return ans;
}
let arr = [1, 2, 3, 4];
let k = 1;
let n = arr.length;
console.log(countSubarray(arr, n, k));
|
The Sliding Window Technique is contributed by Vaibhav Saroj .
Time Complexity: O( n ).
Space Complexity: O( 1 ).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...