Related Articles
Maximum contiguous decreasing sequence obtained by removing any one element
• Last Updated : 20 Aug, 2020

Given an array arr[] of N integers. The task is to find the length of the contiguous strictly decreasing sequence that can be derieved after removing at most one element from the array arr[].

Examples

Input: arr[] = {8, 7, 3, 5, 2, 9}
Output: 4
Explanation:
If we remove 3, The maximum length of decreasing sequence is 4 and the sequence is { 8, 7, 5, 2 }
If we remove 5, The maximum length of decreasing sequence is 4 and the sequence is { 8, 7, 3, 2 }
In both removal we get 4 as the maximum length.

Input: arr[] = {1, 2, 9, 8, 3, 7, 6, 4}
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Create two arrays, left[] which stores the length of decreasing sequence from left to right and right[] which stores the length of decreasing sequence from right to left.
• Traverse the given array arr[].
• If previous element(arr[i-1]) is greater than the next element(arr[i+1]), then check whether removing that element will give the maximum length of decreasing subsequence or not.
• Update the maximum length of decreasing subsequence.

Below is the implementation of the above approach:

## C++

 `// C++ program to find maximum length ` `// of decreasing sequence by removing ` `// at most one element ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the maximum length ` `int` `maxLength(``int``* a, ``int` `n) ` `{ ` `    ``// Intialise maximum length to 1 ` `    ``int` `maximum = 1; ` ` `  `    ``// Intialise left[] to find the ` `    ``// length of decreasing sequence ` `    ``// from left to right ` `    ``int` `left[n]; ` ` `  `    ``// Intialise right[] to find the ` `    ``// length of decreasing sequence ` `    ``// from right to left ` `    ``int` `right[n]; ` ` `  `    ``// Initially store 1 at each index of ` `    ``// left and right array ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``left[i] = 1; ` `        ``right[i] = 1; ` `    ``} ` ` `  `    ``// Iterate over the array arr[] to ` `    ``// store length of decreasing ` `    ``// sequence that can be obtained ` `    ``// at every index in the right array ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` ` `  `        ``if` `(a[i] > a[i + 1]) { ` `            ``right[i] = right[i + 1] + 1; ` `        ``} ` ` `  `        ``// Store the length of longest ` `        ``// continuous decreasing ` `        ``// sequence in maximum ` `        ``maximum = max(maximum, right[i]); ` `    ``} ` ` `  `    ``// Iterate over the array arr[] to ` `    ``// store length of decreasing ` `    ``// sequence that can be obtained ` `    ``// at every index in the left array ` `    ``for` `(``int` `i = 1; i < n; i++) { ` `        ``if` `(a[i] < a[i - 1]) { ` `            ``left[i] = left[i - 1] + 1; ` `        ``} ` `    ``} ` ` `  `    ``if` `(n > 2) { ` `        ``// Check if we can obtain a ` `        ``// longer decreasing sequence ` `        ``// after removal of any element ` `        ``// from the array arr[] with ` `        ``// the help of left[] & right[] ` `        ``for` `(``int` `i = 1; i < n - 1; i++) { ` `            ``if` `(a[i - 1] > a[i + 1]) { ` `                ``maximum = max(maximum, ` `                              ``left[i - 1] + right[i + 1]); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Return maximum length of sequence ` `    ``return` `maximum; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[6] = { 8, 7, 3, 5, 2, 9 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Function calling ` `    ``cout << maxLength(arr, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find maximum length  ` `// of decreasing sequence by removing  ` `// at most one element  ` `class` `GFG { ` `     `  `    ``// Function to find the maximum length  ` `    ``static` `int` `maxLength(``int` `[]a, ``int` `n)  ` `    ``{  ` `        ``// Intialise maximum length to 1  ` `        ``int` `maximum = ``1``;  ` `     `  `        ``// Intialise left[] to find the  ` `        ``// length of decreasing sequence  ` `        ``// from left to right  ` `        ``int` `left [] = ``new` `int``[n];  ` `     `  `        ``// Intialise right[] to find the  ` `        ``// length of decreasing sequence  ` `        ``// from right to left  ` `        ``int` `right[] = ``new` `int``[n];  ` `     `  `        ``// Initially store 1 at each index of  ` `        ``// left and right array  ` `        ``for` `(``int` `i = ``0``; i < n; i++) {  ` `            ``left[i] = ``1``;  ` `            ``right[i] = ``1``;  ` `        ``}  ` `     `  `        ``// Iterate over the array arr[] to  ` `        ``// store length of decreasing  ` `        ``// sequence that can be obtained  ` `        ``// at every index in the right array  ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) {  ` `     `  `            ``if` `(a[i] > a[i + ``1``]) {  ` `                ``right[i] = right[i + ``1``] + ``1``;  ` `            ``}  ` `     `  `            ``// Store the length of longest  ` `            ``// continuous decreasing  ` `            ``// sequence in maximum  ` `            ``maximum = Math.max(maximum, right[i]);  ` `        ``}  ` `     `  `        ``// Iterate over the array arr[] to  ` `        ``// store length of decreasing  ` `        ``// sequence that can be obtained  ` `        ``// at every index in the left array  ` `        ``for` `(``int` `i = ``1``; i < n; i++) {  ` `            ``if` `(a[i] < a[i - ``1``]) {  ` `                ``left[i] = left[i - ``1``] + ``1``;  ` `            ``}  ` `        ``}  ` `     `  `        ``if` `(n > ``2``) {  ` `            ``// Check if we can obtain a  ` `            ``// longer decreasing sequence  ` `            ``// after removal of any element  ` `            ``// from the array arr[] with  ` `            ``// the help of left[] & right[]  ` `            ``for` `(``int` `i = ``1``; i < n - ``1``; i++) {  ` `                ``if` `(a[i - ``1``] > a[i + ``1``]) {  ` `                    ``maximum = Math.max(maximum, left[i - ``1``] + right[i + ``1``]);  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Return maximum length of sequence  ` `        ``return` `maximum;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{  ` `        ``int` `arr[] = { ``8``, ``7``, ``3``, ``5``, ``2``, ``9` `};  ` `        ``int` `n = arr.length;  ` `     `  `        ``// Function calling  ` `        ``System.out.println(maxLength(arr, n));  ` `    ``}    ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 program to find maximum length  ` `# of decreasing sequence by removing  ` `# at most one element  ` ` `  `# Function to find the maximum length  ` `def` `maxLength(a, n) : ` ` `  `    ``# Intialise maximum length to 1  ` `    ``maximum ``=` `1``;  ` ` `  `    ``# Intialise left[] to find the  ` `    ``# length of decreasing sequence  ` `    ``# from left to right  ` `    ``left ``=` `[``0``]``*``n;  ` ` `  `    ``# Intialise right[] to find the  ` `    ``# length of decreasing sequence  ` `    ``# from right to left  ` `    ``right ``=` `[``0``]``*``n;  ` ` `  `    ``# Initially store 1 at each index of  ` `    ``# left and right array  ` `    ``for` `i ``in` `range``(n) : ` `        ``left[i] ``=` `1``;  ` `        ``right[i] ``=` `1``;  ` ` `  `    ``# Iterate over the array arr[] to  ` `    ``# store length of decreasing  ` `    ``# sequence that can be obtained  ` `    ``# at every index in the right array  ` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``) : ` ` `  `        ``if` `(a[i] > a[i ``+` `1``]) : ` `            ``right[i] ``=` `right[i ``+` `1``] ``+` `1``;  ` ` `  `        ``# Store the length of longest  ` `        ``# continuous decreasing  ` `        ``# sequence in maximum  ` `        ``maximum ``=` `max``(maximum, right[i]);  ` ` `  `    ``# Iterate over the array arr[] to  ` `    ``# store length of decreasing  ` `    ``# sequence that can be obtained  ` `    ``# at every index in the left array  ` `    ``for` `i ``in` `range``(``1``, n) : ` `        ``if` `(a[i] < a[i ``-` `1``]) : ` `            ``left[i] ``=` `left[i ``-` `1``] ``+` `1``;  ` ` `  `    ``if` `(n > ``2``) : ` `        ``# Check if we can obtain a  ` `        ``# longer decreasing sequence  ` `        ``# after removal of any element  ` `        ``# from the array arr[] with  ` `        ``# the help of left[] & right[]  ` `        ``for` `i ``in` `range``(``1``, n ``-``1``) : ` `            ``if` `(a[i ``-` `1``] > a[i ``+` `1``]) : ` `                ``maximum ``=` `max``(maximum, left[i ``-` `1``] ``+` `right[i ``+` `1``]); ` ` `  `    ``# Return maximum length of sequence  ` `    ``return` `maximum;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``8``, ``7``, ``3``, ``5``, ``2``, ``9` `];  ` `    ``n ``=` `len``(arr);  ` ` `  `    ``# Function calling  ` `    ``print``(maxLength(arr, n));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# program to find maximum length  ` `// of decreasing sequence by removing  ` `// at most one element  ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Function to find the maximum length  ` `    ``static` `int` `maxLength(``int` `[]a, ``int` `n)  ` `    ``{  ` `        ``// Intialise maximum length to 1  ` `        ``int` `maximum = 1;  ` `     `  `        ``// Intialise left[] to find the  ` `        ``// length of decreasing sequence  ` `        ``// from left to right  ` `        ``int` `[]left = ``new` `int``[n];  ` `     `  `        ``// Intialise right[] to find the  ` `        ``// length of decreasing sequence  ` `        ``// from right to left  ` `        ``int` `[]right = ``new` `int``[n];  ` `     `  `        ``// Initially store 1 at each index of  ` `        ``// left and right array  ` `        ``for` `(``int` `i = 0; i < n; i++) {  ` `            ``left[i] = 1;  ` `            ``right[i] = 1;  ` `        ``}  ` `     `  `        ``// Iterate over the array arr[] to  ` `        ``// store length of decreasing  ` `        ``// sequence that can be obtained  ` `        ``// at every index in the right array  ` `        ``for` `(``int` `i = n - 2; i >= 0; i--) {  ` `     `  `            ``if` `(a[i] > a[i + 1]) {  ` `                ``right[i] = right[i + 1] + 1;  ` `            ``}  ` `     `  `            ``// Store the length of longest  ` `            ``// continuous decreasing  ` `            ``// sequence in maximum  ` `            ``maximum = Math.Max(maximum, right[i]);  ` `        ``}  ` `     `  `        ``// Iterate over the array arr[] to  ` `        ``// store length of decreasing  ` `        ``// sequence that can be obtained  ` `        ``// at every index in the left array  ` `        ``for` `(``int` `i = 1; i < n; i++) {  ` `            ``if` `(a[i] < a[i - 1]) {  ` `                ``left[i] = left[i - 1] + 1;  ` `            ``}  ` `        ``}  ` `     `  `        ``if` `(n > 2) {  ` `            ``// Check if we can obtain a  ` `            ``// longer decreasing sequence  ` `            ``// after removal of any element  ` `            ``// from the array arr[] with  ` `            ``// the help of left[] & right[]  ` `            ``for` `(``int` `i = 1; i < n - 1; i++) {  ` `                ``if` `(a[i - 1] > a[i + 1]) {  ` `                    ``maximum = Math.Max(maximum, left[i - 1] + right[i + 1]);  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Return maximum length of sequence  ` `        ``return` `maximum;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String[] args)  ` `    ``{  ` `        ``int` `[]arr = { 8, 7, 3, 5, 2, 9 };  ` `        ``int` `n = arr.Length;  ` `     `  `        ``// Function calling  ` `        ``Console.WriteLine(maxLength(arr, n));  ` `    ``}    ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```4
```

Time Complexity: O(n)
Auxiliary Space: 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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :