Skip to content
Related Articles

Related Articles

Number of non-decreasing sub-arrays of length less than or equal to K
  • Last Updated : 11 Nov, 2019

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
Output:
5

competitive-programming-img
My Personal Notes
arrow_drop_up
Next
last_page
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 product less than K
04, Oct 17
Number of subarrays having sum less than K
01, Apr 18
Find maximum sum array of length less than or equal to m
03, May 18
Maximum subarray size, such that all subarrays of that size have sum less than k
30, Dec 16
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Number of elements less than or equal to a number in a subarray : MO's Algorithm
30, Apr 20
Largest number less than N with digit sum greater than the digit sum of N
04, Dec 18
Find Largest Special Prime which is less than or equal to a given number
22, Oct 18
Count number of integers less than or equal to N which has exactly 9 divisors
31, Oct 18
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
Find maximum number of elements such that their absolute difference is less than or equal to 1
30, 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
Sum of all array elements less than X and greater than Y for Q queries
18, Jun 20
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
Count sub-arrays which have elements less than or equal to X
17, Nov 17
Minimum swaps required to bring all elements less than or equal to k together
21, Feb 18
Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
18, Feb 19
Count of Multiples of A ,B or C less than or equal to N
24, Sep 19
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