Related Articles

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

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 Articles
Page :