Skip to content
Related Articles

Related Articles

Improve Article

Number of subarrays with maximum values in given range

  • Difficulty Level : Medium
  • Last Updated : 10 May, 2021

Given an array of N elements and L and R, print the number of sub-arrays such that the value of the maximum array element in that subarray is at least L and at most R. 

Examples:  

Input : arr[] = {2, 0, 11, 3, 0}
          L = 1, R = 10
Output : 4 
Explanation: the sub-arrays {2}, {2, 0}, {3} 
and {3, 0} have maximum in range 1-10.

Input : arr[] = {3, 4, 1}
          L = 2, R = 4 
Output : 5
Explanation: the sub-arrays are {3}, {4}, 
{3, 4}, {4, 1} and {3, 4, 1}  

A naive approach will be to iterate for every sub-array and find the number of sub-arrays with the maximum in range L-R. The time complexity of this solution is O(n*n) 
An efficient approach is based on below facts :  

  • Any element > R is never included in any subarray.
  • Any number of elements smaller than L can be included in subarray as long as there is at least one single element between L and R inclusive.
  • The number of all possible subarrays of an array of size N is N * (N + 1)/2. Let countSubarrays(N) = N * (N + 1)/2

We keep track of two counts in the current subarray. 
1) Count of all elements smaller than or equal to R. We call it inc
2) Count of all elements smaller than L. We call it exc.
Our answer for current subarray is countSubarrays(inc) – countSubarrays(exc). We basically remove all those subarrays which are formed by only elements smaller than L.
 

Below is the implementation of the above approach- 



C++




// CPP program to count subarrays whose maximum
// elements are in given range.
#include <bits/stdc++.h>
using namespace std;
 
// function to calculate N*(N+1)/2
long countSubarrys(long n)
{
    return n * (n + 1) / 2;
}
 
// function to count the number of sub-arrays with
// maximum greater then L and less then R.
long countSubarrays(int a[], int n, int L, int R)
{
    long res = 0;
 
    // exc is going to store count of elements
    // smaller than L in current valid subarray.
    // inc is going to store count of elements
    // smaller than or equal to R.
    long exc = 0, inc = 0;
 
    // traverse through all elements of the array
    for (int i = 0; i < n; i++) {
 
        // If the element is greater than R,
        // add current value to result and reset
        // values of exc and inc.
        if (a[i] > R) {
            res += (countSubarrys(inc) - countSubarrys(exc));
            inc = 0;
            exc = 0;
        }
 
        // if it is less than L, then it is included
        // in the sub-arrays
        else if (a[i] < L) {
            exc++;
            inc++;
        }
 
        // if >= L and <= R, then count of
        // subarrays formed by previous chunk
        // of elements formed by only smaller
        // elements is reduced from result.
        else {
            res -= countSubarrys(exc);
            exc = 0;
            inc++;
        }
    }
 
    // Update result.
    res += (countSubarrys(inc) - countSubarrys(exc));
 
    // returns the count of sub-arrays
    return res;
}
 
// driver program
int main()
{
    int a[] = { 2, 0, 11, 3, 0 };
    int n = sizeof(a) / sizeof(a[0]);
    int l = 1, r = 10;
    cout << countSubarrays(a, n, l, r);
    return 0;
}

Java




// Java program to count subarrays
// whose maximum elements are
// in given range.
 
class GFG {
     
// function to calculate N*(N+1)/2
static long countSubarrys(long n)
{
    return n * (n + 1) / 2;
}
 
// function to count the number of
// sub-arrays with maximum greater
// then L and less then R.
static long countSubarrays(int a[], int n,
                             int L, int R)
{
    long res = 0;
 
    // exc is going to store count of elements
    // smaller than L in current valid subarray.
    // inc is going to store count of elements
    // smaller than or equal to R.
    long exc = 0, inc = 0;
 
    // traverse through all elements of the array
    for (int i = 0; i < n; i++) {
 
    // If the element is greater than R,
    // add current value to result and reset
    // values of exc and inc.
    if (a[i] > R) {
        res += (countSubarrys(inc) - countSubarrys(exc));
        inc = 0;
        exc = 0;
    }
 
    // if it is less than L, then it is included
    // in the sub-arrays
    else if (a[i] < L) {
        exc++;
        inc++;
    }
 
    // if >= L and <= R, then count of
    // subarrays formed by previous chunk
    // of elements formed by only smaller
    // elements is reduced from result.
    else {
        res -= countSubarrys(exc);
        exc = 0;
        inc++;
    }
    }
 
    // Update result.
    res += (countSubarrys(inc) - countSubarrys(exc));
 
    // returns the count of sub-arrays
    return res;
}
 
// Driver code
public static void main(String arg[])
{
    int a[] = {2, 0, 11, 3, 0};
    int n = a.length;
    int l = 1, r = 10;
    System.out.print(countSubarrays(a, n, l, r));
}
}
 
// This code is contributed by Anant Agarwal.

Python3




# Python program to count
# subarrays whose maximum
# elements are in given range.
 
# function to calculate N*(N+1)/2
def countSubarrys(n):
 
    return n * (n + 1) // 2
 
  
# function to count the
# number of sub-arrays with
# maximum greater then
# L and less then R.
def countSubarrays(a,n,L,R):
 
    res = 0
  
    # exc is going to store
    # count of elements
    # smaller than L in
    # current valid subarray.
    # inc is going to store
    # count of elements
    # smaller than or equal to R.
    exc = 0
    inc = 0
  
    # traverse through all
    # elements of the array
    for i in range(n):
  
        # If the element is
        # greater than R,
        # add current value
        # to result and reset
        # values of exc and inc.
        if (a[i] > R):
             
            res =res + (countSubarrys(inc) - countSubarrys(exc))
            inc = 0
            exc = 0
         
  
        # if it is less than L,
        # then it is included
        # in the sub-arrays
        elif (a[i] < L):
            exc=exc + 1
            inc=inc + 1
         
  
        # if >= L and <= R, then count of
        # subarrays formed by previous chunk
        # of elements formed by only smaller
        # elements is reduced from result.
        else:
             
            res =res - countSubarrys(exc)
            exc = 0
            inc=inc + 1
  
    # Update result.
    res =res + (countSubarrys(inc) - countSubarrys(exc))
  
    # returns the count of sub-arrays
    return res
     
# Driver code
 
a = [ 2, 0, 11, 3, 0]
n =len(a)
l = 1
r = 10
 
print(countSubarrays(a, n, l, r))
 
# This code is contributed
# by Anant Agarwal.

C#




// C# program to count subarrays
// whose maximum elements are
// in given range.
using System;
 
class GFG
{
     
// function to
// calculate N*(N+1)/2
static long countSubarrys(long n)
{
    return n * (n + 1) / 2;
}
 
// function to count the
// number of sub-arrays
// with maximum greater
// then L and less then R.
static long countSubarrays(int []a, int n,
                           int L, int R)
{
    long res = 0;
 
    // exc is going to store
    // count of elements smaller
    // than L in current valid
    // subarray. inc is going to
    // store count of elements
    // smaller than or equal to R.
    long exc = 0, inc = 0;
 
    // traverse through all
    // elements of the array
    for (int i = 0; i < n; i++)
    {
 
    // If the element is greater
    // than R, add current value
    // to result and reset values
    // of exc and inc.
    if (a[i] > R)
    {
        res += (countSubarrys(inc) -
                countSubarrys(exc));
        inc = 0;
        exc = 0;
    }
 
    // if it is less than L,
    // then it is included
    // in the sub-arrays
    else if (a[i] < L)
    {
        exc++;
        inc++;
    }
 
    // if >= L and <= R, then
    // count of subarrays formed
    // by previous chunk of elements
    // formed by only smaller elements
    // is reduced from result.
    else
    {
        res -= countSubarrys(exc);
        exc = 0;
        inc++;
    }
    }
 
    // Update result.
    res += (countSubarrys(inc) -
            countSubarrys(exc));
 
    // returns the count
    // of sub-arrays
    return res;
}
 
// Driver code
public static void Main()
{
    int []a = {2, 0, 11, 3, 0};
    int n = a.Length;
    int l = 1, r = 10;
    Console.WriteLine(countSubarrays(a, n,
                                     l, r));
}
}
 
// This code is contributed by vt_m.

PHP




<?php
// PHP program to count subarrays
// whose maximum elements are in
// given range.
 
// function to calculate N*(N+1)/2
function countSubarrys($n)
{
    return $n * ($n + 1) / 2;
}
 
// function to count the number
// of sub-arrays with maximum
// greater then L and less then R.
function countSubarrays($a, $n,
                        $L, $R)
{
    $res = 0;
 
    // exc is going to store
    // count of elements smaller
    // than L in current valid
    // subarray. inc is going to
    // store count of elements
    // smaller than or equal to R.
    $exc = 0; $inc = 0;
 
    // traverse through all
    // elements of the array
    for ($i = 0; $i < $n; $i++)
    {
 
        // If the element is greater
        // than R, add current value
        // to result and reset values
        // of exc and inc.
        if ($a[$i] > $R)
        {
            $res += (countSubarrys($inc) -
                     countSubarrys($exc));
            $inc = 0;
            $exc = 0;
        }
 
        // if it is less than L,
        // then it is included
        // in the sub-arrays
        else if ($a[$i] < $L)
        {
            $exc++;
            $inc++;
        }
 
        // if >= L and <= R, then
        // count of subarrays formed
        // by previous chunk of elements
        // formed by only smaller elements
        // is reduced from result.
        else
        {
            $res -= countSubarrys($exc);
            $exc = 0;
            $inc++;
        }
    }
 
    // Update result.
    $res += (countSubarrys($inc) -
             countSubarrys($exc));
 
    // returns the count
    // of sub-arrays
    return $res;
}
 
// Driver Code
$a = array(2, 0, 11, 3, 0 );
$n = count($a);
$l = 1; $r = 10;
echo countSubarrays($a, $n, $l, $r);
 
// This code is contributed
// by anuj_67.
?>

Javascript




<script>
// javascript program to count subarrays
// whose maximum elements are
// in given range.
    // function to calculate N*(N+1)/2
    function countSubarrys(n) {
        return n * (n + 1) / 2;
    }
 
    // function to count the number of
    // sub-arrays with maximum greater
    // then L and less then R.
    function countSubarrays(a , n , L , R) {
        var res = 0;
 
        // exc is going to store count of elements
        // smaller than L in current valid subarray.
        // inc is going to store count of elements
        // smaller than or equal to R.
        var exc = 0, inc = 0;
 
        // traverse through all elements of the array
        for (i = 0; i < n; i++) {
 
            // If the element is greater than R,
            // add current value to result and reset
            // values of exc and inc.
            if (a[i] > R) {
                res += (countSubarrys(inc) - countSubarrys(exc));
                inc = 0;
                exc = 0;
            }
 
            // if it is less than L, then it is included
            // in the sub-arrays
            else if (a[i] < L) {
                exc++;
                inc++;
            }
 
            // if >= L and <= R, then count of
            // subarrays formed by previous chunk
            // of elements formed by only smaller
            // elements is reduced from result.
            else {
                res -= countSubarrys(exc);
                exc = 0;
                inc++;
            }
        }
 
        // Update result.
        res += (countSubarrys(inc) - countSubarrys(exc));
 
        // returns the count of sub-arrays
        return res;
    }
 
    // Driver code
        var a = [ 2, 0, 11, 3, 0 ];
        var n = a.length;
        var l = 1, r = 10;
        document.write(countSubarrays(a, n, l, r));
 
// This code is contributed by todaysgaurav
</script>

Output:  

4

Time Complexity: O(n)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :