Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Number of non-decreasing sub-arrays of length less than or equal to K

  • Last Updated : 14 May, 2021

Given an array arr[] of N elements and an integer K, the task is to find the number of non-decreasing sub-arrays of length less than or equal to K.
Examples: 
 

Input: arr[] = {1, 2, 3}, K = 2 
Output: 5 
{1}, {2}, {3}, {1, 2} and {2, 3} are the valid subarrays.
Input: arr[] = {3, 2, 1}, K = 1 
Output: 3 
 

 

Naive approach: A simple approach is to generate all the sub-arrays of length less than or equal to K and then check whether the sub-array satisfies the condition. Thus, the time complexity of the approach will be O(N3).
Efficient approach: A better approach will be using the two-pointer technique. 
 

  • For any index i, find the largest index j such that the sub-array arr[i…j] is non-decreasing. This can be achieved by simply increasing the value of j, starting from i + 1 and checking whether arr[j] is greater than arr[j – 1].
  • Lets say that the length of the sub-array found in the previous step is L. Calculate X = max(0, L – K) and (L * (L + 1)) / 2 – (X * (X + 1)) / 2 will be added to the final answer. This is because for an array of length L, the number of sub-arrays with length ≥ K. 
    • Number of such sub-arrays starting from the first element = L – K = X.
    • Number of such sub-arrays starting from the second element = L – K – 1 = X – 1.
    • Number of such sub-arrays starting from the third element = L – K – 2 = X – 2.
    • And so on until 0 i.e. 1 + 2 + 3 + .. + X = (X * (X + 1)) / 2. If this value is subtracted from the total increasing subarrays then the result will be the count of increasing subarrays of length less than or equal to K

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the required count
int findCnt(int* arr, int n, int k)
{
    // To store the final result
    int ret = 0;
 
    // Two pointer loop
    int i = 0;
    while (i < n) {
 
        // Initialising j
        int j = i + 1;
 
        // Looping till the subarray increases
        while (j < n and arr[j] >= arr[j - 1])
            j++;
        int x = max(0, j - i - k);
 
        // Update ret
        ret += ((j - i) * (j - i + 1)) / 2 - (x * (x + 1)) / 2;
 
        // Update i
        i = j;
    }
 
    // Return ret
    return ret;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3 };
    int n = sizeof(arr) / sizeof(int);
    int k = 2;
 
    cout << findCnt(arr, n, k);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
 
// Function to return the required count
static int findCnt(int[] arr, int n, int k)
{
    // To store the final result
    int ret = 0;
 
    // Two pointer loop
    int i = 0;
    while (i < n)
    {
 
        // Initialising j
        int j = i + 1;
 
        // Looping till the subarray increases
        while (j < n && arr[j] >= arr[j - 1])
            j++;
        int x = Math.max(0, j - i - k);
 
        // Update ret
        ret += ((j - i) * (j - i + 1)) / 2 -
                          (x * (x + 1)) / 2;
 
        // Update i
        i = j;
    }
 
    // Return ret
    return ret;
}
 
// Driver code
public static void main(String []args)
{
    int arr[] = { 1, 2, 3 };
    int n = arr.length;
    int k = 2;
 
    System.out.println(findCnt(arr, n, k));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
 
# Function to return the required count
def findCnt(arr, n, k) :
 
    # To store the final result
    ret = 0;
 
    # Two pointer loop
    i = 0;
    while (i < n) :
 
        # Initialising j
        j = i + 1;
 
        # Looping till the subarray increases
        while (j < n and arr[j] >= arr[j - 1]) :
            j += 1;
             
        x = max(0, j - i - k);
 
        # Update ret
        ret += ((j - i) * (j - i + 1)) // 2 - \
                          (x * (x + 1)) / 2;
 
        # Update i
        i = j;
 
    # Return ret
    return ret;
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 3 ];
    n = len(arr);
    k = 2;
 
    print(findCnt(arr, n, k));
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
                     
class GFG
{
 
// Function to return the required count
static int findCnt(int[] arr, int n, int k)
{
    // To store the final result
    int ret = 0;
 
    // Two pointer loop
    int i = 0;
    while (i < n)
    {
 
        // Initialising j
        int j = i + 1;
 
        // Looping till the subarray increases
        while (j < n && arr[j] >= arr[j - 1])
            j++;
        int x = Math.Max(0, j - i - k);
 
        // Update ret
        ret += ((j - i) * (j - i + 1)) / 2 -
                        (x * (x + 1)) / 2;
 
        // Update i
        i = j;
    }
 
    // Return ret
    return ret;
}
 
// Driver code
public static void Main(String []args)
{
    int []arr = { 1, 2, 3 };
    int n = arr.Length;
    int k = 2;
 
    Console.WriteLine(findCnt(arr, n, k));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to return the required count
function findCnt(arr, n, k)
{
    // To store the final result
    var ret = 0;
 
    // Two pointer loop
    var i = 0;
    while (i < n) {
 
        // Initialising j
        var j = i + 1;
 
        // Looping till the subarray increases
        while (j < n && arr[j] >= arr[j - 1])
            j++;
        var x = Math.max(0, j - i - k);
 
        // Update ret
        ret += ((j - i) * (j - i + 1)) / 2 - (x * (x + 1)) / 2;
 
        // Update i
        i = j;
    }
 
    // Return ret
    return ret;
}
 
// Driver code
var arr = [1, 2, 3 ];
var n = arr.length;
var k = 2;
document.write( findCnt(arr, n, k));
 
</script>
Output: 
5
 

My Personal Notes
arrow_drop_up
Next

Number of non-decreasing sub-arrays of length greater than or equal to K
Recommended Articles
Page :
Maximum length L such that the sum of all subarrays of length L is less than K
20, Jan 20
Count N-length arrays made from first M natural numbers whose subarrays can be made palindromic by replacing less than half of its elements
16, Dec 20
Find all possible subarrays having product less than or equal to K
31, Aug 20
Number of subarrays having sum less than K
01, Apr 18
Number of subarrays having product less than K
04, Oct 17
Find maximum sum array of length less than or equal to m
03, May 18
Number of elements less than or equal to a number in a subarray : MO's Algorithm
30, Apr 20
Maximum subarray size, such that all subarrays of that size have sum less than k
30, Dec 16
Reduce given array by replacing subarrays with values less than K with their sum
10, Sep 21
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Largest number less than N with digit sum greater than the digit sum of N
04, Dec 18
Find maximum number of elements such that their absolute difference is less than or equal to 1
30, Oct 18
Count number of integers less than or equal to N which has exactly 9 divisors
31, Oct 18
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
17, Apr 19
Number of sub-sequence such that it has one consecutive element with difference less than or equal to 1
11, Jun 19
Count the number of strings in an array whose distinct characters are less than equal to M
06, May 20
Find all powers of 2 less than or equal to a given number
23, Jun 20
Count array elements whose highest power of 2 less than or equal to that number is present in the given array
17, Jun 21
Number of players whose rank is equal to or less than a given cutoff rank
21, Jul 21
Find Largest Special Prime which is less than or equal to a given number
22, Oct 18
Sum of all array elements less than X and greater than Y for Q queries
18, Jun 20
Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0
13, Dec 21
Count of integers of length N and value less than K such that they contain digits only from the given set
02, Jul 19
Count elements less than or equal to a given value in a sorted rotated array
15, Jun 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
DivyanshuShekhar1
@DivyanshuShekhar1
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!