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

01 Apr, 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 in 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++
Java
Python3
C#
Javascript
// 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 elementint 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 codeint main(){    int arr[] = { 1, 2 };    int n = sizeof(arr) / sizeof(int);     cout << maxIncSubarr(arr, n);     return 0;}
// Java implementation of the approachclass 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
# Python implementation of the approach # Function to return the maximum length of# strictly increasing subarray after# removing atmost one elementdef 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 codeif __name__ == '__main__':    arr = [ 1, 2 ];    n = len(arr);     print(maxIncSubarr(arr, n));     # This code is contributed by PrinciRaj1992
// C# implementation of the approachusing 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
<script> // Javascript implementation of the approach // Function to return the maximum length of// strictly increasing subarray after// removing atmost one elementfunction 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 codelet arr = [ 1, 2 ];let n = arr.length; document.write(maxIncSubarr(arr, n)); // This code is contributed by rameshtravel07 </script>
2
 
Time Complexity: O(N)
Space Complexity: O(N)
ankthon
princiraj1992
sriashi0397
YashSharmaEmbark
OmkarKhodwe1
rameshtravel07
simranarora5sos
subarray
Arrays
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.