Maximum length of Strictly Increasing Sub-array after removing at most one element

Last Updated : 09 Dec, 2022

Given an array arr[], the task is to remove at most one element and calculate the maximum length of strictly increasing subarray.

Examples:

Input: arr[] = {1, 2, 5, 3, 4}
Output: 4
After deleting 5, the resulting array will be {1, 2, 3, 4}
and the maximum length of its strictly increasing subarray is 4.

Input: arr[] = {1, 2}
Output: 2
The complete array is already strictly increasing.

Approach:

Create two arrays pre[] and pos[] of size N.
Iterate over the input array arr[] from (0, N) to find out the contribution of the current element arr[i] in the array till now [0, i) and update the pre[] array if it contributes to the strictly increasing subarray.
Iterate over the input array arr[] from [N - 2, 0] to find out the contribution of the current element arr[j] in the array till now (N, j) and update the pos[] array if arr[j] contributes in the longest increasing subarray.
Calculate the maximum length of the strictly increasing subarray without removing any element.
Iterate over the array pre[] and pos[] to find out the contribution of the current element by excluding that element.
Maintain a variable ans to find the maximum found till now.

Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the maximum length of strictly
// increasing subarray after removing atmost one element
int maxIncSubarr(int a[], int n)
{
    // Create two arrays pre and pos
    int pre[n] = { 0 };
    int pos[n] = { 0 };
    pre[0] = 1;
    pos[n - 1] = 1;
    int l = 0;

    // Find out the contribution of the current element in
    // array[0, i] and update pre[i]
    for (int i = 1; i < n; i++) {
        if (a[i] > a[i - 1])
            pre[i] = pre[i - 1] + 1;
        else
            pre[i] = 1;
    }

    // Find out the contribution of the current element in
    // array[N - 1, i] and update pos[i]
    l = 1;
    for (int i = n - 2; i >= 0; i--) {
        if (a[i] < a[i + 1])
            pos[i] = pos[i + 1] + 1;
        else
            pos[i] = 1;
    }

    // Calculate the maximum length of the strictly
    // increasing subarray without removing any element
    int ans = 0;
    l = 1;
    for (int i = 1; i < n; i++) {
        if (a[i] > a[i - 1])
            l++;
        else
            l = 1;
        ans = max(ans, l);
    }

    // Calculate the maximum length of the strictly
    // increasing subarray after removing the current
    // element
    for (int i = 1; i <= n - 2; i++)
        if (a[i - 1] < a[i + 1])
            ans = max(pre[i - 1] + pos[i + 1], ans);

    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 2 };
    int n = sizeof(arr) / sizeof(int);
    cout << maxIncSubarr(arr, n);
    return 0;
}

// C implementation of the approach
#include <stdio.h>

// Find maximum between two numbers.
int max(int num1, int num2)
{
    return (num1 > num2) ? num1 : num2;
}

// Function to return the maximum length of strictly
// increasing subarray after removing atmost one element
int maxIncSubarr(int a[], int n)
{
    // Create two arrays pre and pos
    int pre[n];
    int pos[n];
    for (int i = 0; i < n; i++)
        pre[i] = 0;
    for (int i = 0; i < n; i++)
        pos[i] = 0;

    pre[0] = 1;
    pos[n - 1] = 1;
    int l = 0;

    // Find out the contribution of the current element in
    // array[0, i] and update pre[i]
    for (int i = 1; i < n; i++) {
        if (a[i] > a[i - 1])
            pre[i] = pre[i - 1] + 1;
        else
            pre[i] = 1;
    }

    // Find out the contribution of the current element in
    // array[N - 1, i] and update pos[i]
    l = 1;
    for (int i = n - 2; i >= 0; i--) {
        if (a[i] < a[i + 1])
            pos[i] = pos[i + 1] + 1;
        else
            pos[i] = 1;
    }

    // Calculate the maximum length of the strictly
    // increasing subarray without removing any element
    int ans = 0;
    l = 1;
    for (int i = 1; i < n; i++) {
        if (a[i] > a[i - 1])
            l++;
        else
            l = 1;
        ans = max(ans, l);
    }

    // Calculate the maximum length of the strictly
    // increasing subarray after removing the current
    // element
    for (int i = 1; i <= n - 2; i++)
        if (a[i - 1] < a[i + 1])
            ans = max(pre[i - 1] + pos[i + 1], ans);

    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 2 };
    int n = sizeof(arr) / sizeof(int);
    printf("%d", maxIncSubarr(arr, n));
    return 0;
}

// This code is contributed by Sania Kumari Gupta

Java

// Java implementation of the approach 
import java.io.*;

class GFG 
{
    
    // Function to return the maximum length of 
    // strictly increasing subarray after 
    // removing atmost one element 
    static int maxIncSubarr(int a[], int n) 
    { 
        // Create two arrays pre and pos 
        int pre[] = new int[n] ; 
        int pos[] = new int[n] ; 
        pre[0] = 1; 
        pos[n - 1] = 1; 
        int l = 0; 
    
        // Find out the contribution of the current 
        // element in array[0, i] and update pre[i] 
        for (int i = 1; i < n; i++)
        { 
            if (a[i] > a[i - 1]) 
                pre[i] = pre[i - 1] + 1; 
            else
                pre[i] = 1; 
        } 
    
        // Find out the contribution of the current 
        // element in array[N - 1, i] and update pos[i] 
        l = 1; 
        for (int i = n - 2; i >= 0; i--)
        { 
            if (a[i] < a[i + 1]) 
                pos[i] = pos[i + 1] + 1; 
            else
                pos[i] = 1; 
        } 
    
        // Calculate the maximum length of the 
        // strictly increasing subarray without 
        // removing any element 
        int ans = 0; 
        l = 1; 
        for (int i = 1; i < n; i++)
        { 
            if (a[i] > a[i - 1]) 
                l++; 
            else
                l = 1; 
            ans = Math.max(ans, l); 
        } 
    
        // Calculate the maximum length of the 
        // strictly increasing subarray after 
        // removing the current element 
        for (int i = 1; i <= n - 2; i++) 
        { 
            if (a[i - 1] < a[i + 1]) 
                ans = Math.max(pre[i - 1] + 
                                pos[i + 1], ans); 
        } 
        return ans; 
    } 
    
    // Driver code 
    public static void main (String[] args)
    { 
        int arr[] = {1, 2}; 
        int n = arr.length; 
    
        System.out.println(maxIncSubarr(arr, n)); 
    } 
}

// This code is contributed by AnkitRai01

Python3

# Python implementation of the approach 

# Function to return the maximum length of
# strictly increasing subarray after
# removing atmost one element
def maxIncSubarr(a, n):
    
    # Create two arrays pre and pos
    pre = [0] * n;
    pos = [0] * n;
    pre[0] = 1;
    pos[n - 1] = 1;
    l = 0;

    # Find out the contribution of the current
    # element in array[0, i] and update pre[i]
    for i in range(1, n):
        if (a[i] > a[i - 1]):
            pre[i] = pre[i - 1] + 1;
        else:
            pre[i] = 1;
    
    # Find out the contribution of the current
    # element in array[N - 1, i] and update pos[i]
    l = 1;
    for i in range(n - 2, -1, -1):
        if (a[i] < a[i + 1]):
            pos[i] = pos[i + 1] + 1;
        else:
            pos[i] = 1;
    
    # Calculate the maximum length of the
    # strictly increasing subarray without
    # removing any element
    ans = 0;
    l = 1;
    for i in range(1, n):
        if (a[i] > a[i - 1]):
            l += 1;
        else:
            l = 1;
        ans = max(ans, l);
    
    # Calculate the maximum length of the
    # strictly increasing subarray after
    # removing the current element
    for i in range(1, n - 1):
        if (a[i - 1] < a[i + 1]):
            ans = max(pre[i - 1] + pos[i + 1], ans);
    
    return ans;

# Driver code
if __name__ == '__main__':
    arr = [ 1, 2 ];
    n = len(arr);

    print(maxIncSubarr(arr, n));
    
# This code is contributed by PrinciRaj1992

// C# implementation of the approach 
using System;

class GFG 
{
    
    // Function to return the maximum length of 
    // strictly increasing subarray after 
    // removing atmost one element 
    static int maxIncSubarr(int []a, int n) 
    { 
        // Create two arrays pre and pos 
        int []pre = new int[n] ; 
        int []pos = new int[n] ; 
        pre[0] = 1; 
        pos[n - 1] = 1; 
        int l = 0; 
    
        // Find out the contribution of the current 
        // element in array[0, i] and update pre[i] 
        for (int i = 1; i < n; i++)
        { 
            if (a[i] > a[i - 1]) 
                pre[i] = pre[i - 1] + 1; 
            else
                pre[i] = 1; 
        } 
    
        // Find out the contribution of the current 
        // element in array[N - 1, i] and update pos[i] 
        l = 1; 
        for (int i = n - 2; i >= 0; i--)
        { 
            if (a[i] < a[i + 1]) 
                pos[i] = pos[i + 1] + 1; 
            else
                pos[i] = 1; 
        } 
    
        // Calculate the maximum length of the 
        // strictly increasing subarray without 
        // removing any element 
        int ans = 0; 
        l = 1; 
        for (int i = 1; i < n; i++)
        { 
            if (a[i] > a[i - 1]) 
                l++; 
            else
                l = 1; 
            ans = Math.Max(ans, l); 
        } 
    
        // Calculate the maximum length of the 
        // strictly increasing subarray after 
        // removing the current element 
        for (int i = 1; i <= n - 2; i++) 
        { 
            if (a[i - 1] < a[i + 1]) 
                ans = Math.Max(pre[i - 1] + 
                                pos[i + 1], ans); 
        } 
        return ans; 
    } 
    
    // Driver code 
    public static void Main()
    { 
        int []arr = {1, 2}; 
        int n = arr.Length; 
    
        Console.WriteLine(maxIncSubarr(arr, n)); 
    } 
}

// This code is contributed by AnkitRai01

JavaScript

<script>

// Javascript implementation of the approach

// Function to return the maximum length of
// strictly increasing subarray after
// removing atmost one element
function maxIncSubarr(a, n)
{
    
    // Create two arrays pre and pos
    let pre = new Array(n);
    let pos = new Array(n);
    pre.fill(0);
    pos.fill(0);
    pre[0] = 1;
    pos[n - 1] = 1;
    let l = 0;

    // Find out the contribution of the current
    // element in array[0, i] and update pre[i]
    for(let i = 1; i < n; i++)
    {
        if (a[i] > a[i - 1])
            pre[i] = pre[i - 1] + 1;
        else
            pre[i] = 1;
    }

    // Find out the contribution of the current
    // element in array[N - 1, i] and update pos[i]
    l = 1;
    for(let i = n - 2; i >= 0; i--)
    {
        if (a[i] < a[i + 1])
            pos[i] = pos[i + 1] + 1;
        else
            pos[i] = 1;
    }

    // Calculate the maximum length of the
    // strictly increasing subarray without
    // removing any element
    let ans = 0;
    l = 1;
    for(let i = 1; i < n; i++)
    {
        if (a[i] > a[i - 1])
            l++;
        else
            l = 1;
        ans = Math.max(ans, l);
    }

    // Calculate the maximum length of the
    // strictly increasing subarray after
    // removing the current element
    for(let i = 1; i <= n - 2; i++) 
    {
        if (a[i - 1] < a[i + 1])
            ans = Math.max(pre[i - 1] + 
                           pos[i + 1], ans);
    }
    return ans;
}

// Driver code
let arr = [ 1, 2 ];
let n = arr.length;

document.write(maxIncSubarr(arr, n));

// This code is contributed by rameshtravel07

</script>

Output

Time Complexity: O(N)
Auxiliary Space: O(N)

Maximize length of Non-Decreasing Subsequence by reversing at most one Subarray

DiptayanBiswas

Improve

Article Tags :

Practice Tags :

Maximum length of Strictly Increasing Sub-array after removing at most one element

Similar Reads

Thank You!

What kind of Experience do you want to share?