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)
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.
Recommended Posts:
- Minimum increments of Non-Decreasing Subarrays required to make Array Non-Decreasing
- Differences between number of increasing subarrays and decreasing subarrays in k sized windows
- Find an element in an array such that elements form a strictly decreasing and increasing sequence
- Count Strictly Increasing Subarrays
- 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 non decreasing subarrays of size N from N Natural numbers
- 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
- Find Maximum Sum Strictly Increasing Subarray
- Find the largest composite number that divides N but is strictly lesser than N
- Find just strictly greater element from first array for each element in second array
- Count subarrays such that remainder after dividing sum of elements by K gives count of elements
- Count permutation such that sequence is non decreasing
- Count permutations that are first decreasing then increasing.
- Count of non decreasing arrays of length N formed with values in range L to R
- Count the number of contiguous increasing and decreasing subsequences in a sequence
- Count of decreasing pairs formed from numbers 1 to N
- Maximize count of Decreasing Consecutive Subsequences from an Array
- Generate k digit numbers with digits in strictly increasing order
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.
