Find the count of Strictly decreasing Subarrays
Given an array A[] of integers. The task is to count the total number of strictly decreasing subarrays( with size > 1 ).
Examples:
Input : A[] = { 100, 3, 1, 15 }
Output : 3
Subarrays are -> { 100, 3 }, { 100, 3, 1 }, { 3, 1 }
Input : A[] = { 4, 2, 2, 1 }
Output : 2
Naive Approach: A simple solution is to run two for loops and check whether the subarray is decreasing or not.
This can be improved by knowing the fact that if subarray arr[i:j] is not strictly decreasing, then subarrays arr[i:j+1], arr[i:j+2], .. arr[i:n-1] cannot be strictly decreasing.
Efficient Approach: In above solution we count many subarrays twice. This can also be improved and the idea is based on fact that a sorted(decreasing) subarray of length ‘len’ adds len*(len-1)/2 to result.
Below is the implementation of above approach:
C++
// C++ program to count number of strictly // decreasing subarrays in O(n) time. #include <bits/stdc++.h> using namespace std; // Function to count the number of strictly // decreasing subarrays int countDecreasing(int A[], int n) { int cnt = 0; // Initialize result // Initialize length of current // decreasing subarray int len = 1; // Traverse through the array for (int i = 0; i < n - 1; ++i) { // If arr[i+1] is less than arr[i], // then increment length if (A[i + 1] < A[i]) len++; // Else Update count and reset length else { cnt += (((len - 1) * len) / 2); len = 1; } } // If last length is more than 1 if (len > 1) cnt += (((len - 1) * len) / 2); return cnt; } // Driver program int main() { int A[] = { 100, 3, 1, 13 }; int n = sizeof(A) / sizeof(A[0]); cout << countDecreasing(A, n); return 0; } |
chevron_right
filter_none
Java
// Java program to count number of strictly // decreasing subarrays in O(n) time. import java.io.*; class GFG { // Function to count the number of strictly // decreasing subarrays static int countDecreasing(int A[], int n) { int cnt = 0; // Initialize result // Initialize length of current // decreasing subarray int len = 1; // Traverse through the array for (int i = 0; i < n - 1; ++i) { // If arr[i+1] is less than arr[i], // then increment length if (A[i + 1] < A[i]) len++; // Else Update count and reset length else { cnt += (((len - 1) * len) / 2); len = 1; } } // If last length is more than 1 if (len > 1) cnt += (((len - 1) * len) / 2); return cnt; } // Driver program public static void main (String[] args) { int A[] = { 100, 3, 1, 13 }; int n = A.length; System.out.println(countDecreasing(A, n)); } } // This code is contributed by anuj_67.. |
chevron_right
filter_none
Python 3
# Python 3 program to count number # of strictly decreasing subarrays # in O(n) time. # Function to count the number of # strictly decreasing subarrays def countDecreasing(A, n): cnt = 0 # Initialize result # Initialize length of current # decreasing subarray len = 1 # Traverse through the array for i in range (n - 1) : # If arr[i+1] is less than arr[i], # then increment length if (A[i + 1] < A[i]): len += 1 # Else Update count and # reset length else : cnt += (((len - 1) * len) // 2); len = 1 # If last length is more than 1 if (len > 1): cnt += (((len - 1) * len) // 2) return cnt # Driver Code if __name__=="__main__": A = [ 100, 3, 1, 13 ] n = len(A) print (countDecreasing(A, n)) # This code is contributed by ChitraNayal |
chevron_right
filter_none
C#
// C# program to count number of strictly // decreasing subarrays in O(n) time. using System; class GFG { // Function to count the number of strictly // decreasing subarrays static int countDecreasing(int []A, int n) { int cnt = 0; // Initialize result // Initialize length of current // decreasing subarray int len = 1; // Traverse through the array for (int i = 0; i < n - 1; ++i) { // If arr[i+1] is less than arr[i], // then increment length if (A[i + 1] < A[i]) len++; // Else Update count and reset length else { cnt += (((len - 1) * len) / 2); len = 1; } } // If last length is more than 1 if (len > 1) cnt += (((len - 1) * len) / 2); return cnt; } // Driver code static void Main() { int []A = { 100, 3, 1, 13 }; int n = A.Length ; Console.WriteLine(countDecreasing(A, n)); } // This code is contributed by ANKITRAI1 } |
chevron_right
filter_none
PHP
<?php // PHP program to count number of strictly // decreasing subarrays in O(n) time. // Function to count the number of // strictly decreasing subarrays function countDecreasing($A, $n) { $cnt = 0; // Initialize result // Initialize length of current // decreasing subarray $len = 1; // Traverse through the array for ($i = 0; $i < $n - 1; ++$i) { // If arr[i+1] is less than arr[i], // then increment length if ($A[$i + 1] < $A[$i]) $len++; // Else Update count and // reset length else { $cnt += ((($len - 1) * $len) / 2); $len = 1; } } // If last length is more than 1 if ($len > 1) $cnt += ((($len - 1) * $len) / 2); return $cnt; } // Driver Code $A = array( 100, 3, 1, 13 ); $n = sizeof($A); echo countDecreasing($A, $n); // This code is contributed by mits ?> |
chevron_right
filter_none
Output:
3
Time Complexity: O(N)
GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details
Recommended Posts:
- Count Strictly Increasing Subarrays
- Count non decreasing subarrays of size N from N Natural numbers
- Find an element in an array such that elements form a strictly decreasing and increasing sequence
- Differences between number of increasing subarrays and decreasing subarrays in k sized windows
- Check whether an array can be made strictly decreasing by modifying at most one element
- Split the array elements into strictly increasing and decreasing sequence
- Count the subarray with sum strictly greater than the sum of remaining elements
- Count ways to divide C in two parts and add to A and B to make A strictly greater than B
- Count permutations that are first decreasing then increasing.
- Count permutation such that sequence is non decreasing
- Count of decreasing pairs formed from numbers 1 to N
- Find Maximum Sum Strictly Increasing Subarray
- Count the number of contiguous increasing and decreasing subsequences in a sequence
- Count of non decreasing arrays of length N formed with values in range L to R
- Count of subarrays with sum at least K
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
