Maximum contiguous decreasing sequence obtained by removing any one element

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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find maximum length
// of decreasing sequence by removing
// at most one element
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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 Posts:


Check out this Author's contributed articles.

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.



Improved By : AnkitRai01, nidhi_biet