# Maximum length of longest increasing contiguous subarray after deleting exactly one element from array

• Difficulty Level : Medium
• Last Updated : 09 Nov, 2021

Given an array arr[ ] of N integers. The task is to find the maximum length of the longest increasing contiguous subarray after removing exactly one element from the given array.
Examples :

Input : N = 5, arr[] = { 2, 4, 1, 5, 7 }
Output : 4
Explanation : After removing third element from the array, the array arr[ ] becomes [2, 4, 5, 7] . therefore, the length of longest increasing contiguous subarray is 4, which is  maximum.
Input :  N = 4, arr[] = { 2, 1, 3, 1 }
Output : 2
Explanation : We can either remove the second or first element from the array, and the array, arr[ ] becomes {1, 3, 1} or {2, 3, 1}, and the length of longest increasing contiguous subarray is 2, which is maximum.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach: The task can be solved by keeping track of the longest increasing subsequence starting from index ‘i’, and also ending at index ‘i’.

• Create two arrays front[ ] and back[ ] of size N and initialize both arrays with 1.
• Calculate front[i] and back[i] for each i from 1 to N, where front[i] represents the maximum length of longest increasing subsequence starting from the position i and back[i] represents the maximum length of longest increasing subsequence ending at position i.
• The array front[ ] can be calculated in order from left to right with the following condition : if(a[i] > a[i-1]) update front[i] = front[i-1] + 1, else continue . In same way, array back[ ] can be calculated in order from right to left with the following condition : if(a[i] < a[i+1]) update back[i] = back[i+1] + 1, else continue
• Now calculate the ans, initialized with 1, with these two arrays.
• Update ans if (a[i] < a[i+2]), it means (i+1)th element is getting deleted, same with back[] array.

Below is the implementation of the above approach:

## C++

 `// c++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum length of longest``// increasing contiguous subarray after removing``// exactly one element from array``int` `maxLenSubarr(``int` `arr[], ``int` `n)``{``    ``// Creating front[] and back[] arrays``    ``int` `front[n], back[n];``    ``for` `(``int` `i = 0; i < n; i++) {``        ``front[i] = 1;``        ``back[i] = 1;``    ``}` `    ``// Calculating the front[]``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(arr[i] > arr[i - 1]) {` `            ``// Update front[i]``            ``front[i] = front[i - 1] + 1;``        ``}``    ``}` `    ``// Calculating the back[]``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``        ``if` `(arr[i] < arr[i + 1]) {` `            ``// update back[i]``            ``back[i] = back[i + 1] + 1;``        ``}``    ``}` `    ``// Store the length of longest increasing``    ``// contiguous subarray``    ``int` `ans = 1;` `    ``// Check whether first element is``    ``// contributing in subarray or not``    ``bool` `check_first = ``true``;` `    ``// Keep track of longest subarray when``    ``// first element is removed``    ``int` `ans_first = 1;` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// front[i] == 1 means contribution of``        ``// first element in max``        ``// length subarray has ended``        ``if` `(front[i] == 1) {``            ``check_first = ``true``;``        ``}` `        ``ans_first = max(ans_first, front[i]);``    ``}` `    ``// First element contributes in the subarray``    ``if` `(check_first == ``false``) {``        ``ans_first -= 1;``    ``}` `    ``// Check whether last element is``    ``// contributing in subarray or not``    ``bool` `check_last = ``true``;` `    ``// Keep track of longest subarray when``    ``// last element is removed``    ``int` `ans_last = 1;` `    ``for` `(``int` `i = n - 2; i >= 0; i--) {` `        ``// back[i] == 1 means contribution of``        ``// last element in max``        ``// length subarray has ended``        ``if` `(back[i] == 1) {``            ``check_last = ``true``;``        ``}``        ``ans_last = max(ans_last, back[i]);``    ``}` `    ``// Last element contributes in the subarray``    ``if` `(check_last == ``false``) {``        ``ans_last -= 1;``    ``}` `    ``// Update ans``    ``ans = max(ans_first, ans_last);` `    ``// Calculating max length when``    ``// (i+1)th element is deleted``    ``for` `(``int` `i = 0; i < n - 2; i++) {``        ``if` `(arr[i] < arr[i + 2]) {``            ``ans = max(ans,``                      ``front[i] + back[i + 2]);``        ``}``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 2, 1, 3, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << maxLenSubarr(arr, n);``    ``return` `0;``}`

## Java

 `// Java program for the above approach` `public` `class` `GFG {` `// Function to find the maximum length of longest``// increasing contiguous subarray after removing``// exactly one element from array``static` `int` `maxLenSubarr(``int` `arr[], ``int` `n)``{``    ``// Creating front[] and back[] arrays``    ``int` `front[] = ``new` `int``[n];``    ``int` `back[] = ``new` `int``[n];``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``front[i] = ``1``;``        ``back[i] = ``1``;``    ``}` `    ``// Calculating the front[]``    ``for` `(``int` `i = ``1``; i < n; i++) {``        ``if` `(arr[i] > arr[i - ``1``]) {` `            ``// Update front[i]``            ``front[i] = front[i - ``1``] + ``1``;``        ``}``    ``}` `    ``// Calculating the back[]``    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) {``        ``if` `(arr[i] < arr[i + ``1``]) {` `            ``// update back[i]``            ``back[i] = back[i + ``1``] + ``1``;``        ``}``    ``}` `    ``// Store the length of longest increasing``    ``// contiguous subarray``    ``int` `ans = ``1``;` `    ``// Check whether first element is``    ``// contributing in subarray or not``    ``boolean` `check_first = ``true``;` `    ``// Keep track of longest subarray when``    ``// first element is removed``    ``int` `ans_first = ``1``;` `    ``for` `(``int` `i = ``1``; i < n; i++) {` `        ``// front[i] == 1 means contribution of``        ``// first element in max``        ``// length subarray has ended``        ``if` `(front[i] == ``1``) {``            ``check_first = ``true``;``        ``}` `        ``ans_first = Math.max(ans_first, front[i]);``    ``}` `    ``// First element contributes in the subarray``    ``if` `(check_first == ``false``) {``        ``ans_first -= ``1``;``    ``}` `    ``// Check whether last element is``    ``// contributing in subarray or not``    ``boolean` `check_last = ``true``;` `    ``// Keep track of longest subarray when``    ``// last element is removed``    ``int` `ans_last = ``1``;` `    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) {` `        ``// back[i] == 1 means contribution of``        ``// last element in max``        ``// length subarray has ended``        ``if` `(back[i] == ``1``) {``            ``check_last = ``true``;``        ``}``        ``ans_last = Math.max(ans_last, back[i]);``    ``}` `    ``// Last element contributes in the subarray``    ``if` `(check_last == ``false``) {``        ``ans_last -= ``1``;``    ``}` `    ``// Update ans``    ``ans = Math.max(ans_first, ans_last);` `    ``// Calculating max length when``    ``// (i+1)th element is deleted``    ``for` `(``int` `i = ``0``; i < n - ``2``; i++) {``        ``if` `(arr[i] < arr[i + ``2``]) {``            ``ans = Math.max(ans,``                      ``front[i] + back[i + ``2``]);``        ``}``    ``}` `    ``return` `ans;``}` `    ``// Driver code``    ``public` `static` `void` `main (String[] args) {``        ` `        ``int` `arr[] = { ``2``, ``1``, ``3``, ``1` `};``        ``int` `n = arr.length;``        ``System.out.println(maxLenSubarr(arr, n));``    ``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum length of longest``# increasing contiguous subarray after removing``# exactly one element from array``def` `maxLenSubarr(arr, n) :` `    ``# Creating front[] and back[] arrays``    ``front ``=` `[``0``] ``*` `n;  back ``=` `[``0``] ``*` `n;``    ``for` `i ``in` `range``(n) :``        ``front[i] ``=` `1``;``        ``back[i] ``=` `1``;` `    ``# Calculating the front[]``    ``for` `i ``in` `range``(``1``, n) :``        ``if` `(arr[i] > arr[i ``-` `1``]) :` `            ``# Update front[i]``            ``front[i] ``=` `front[i ``-` `1``] ``+` `1``;` `    ``# Calculating the back[]``    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``) :``        ``if` `(arr[i] < arr[i ``+` `1``]) :` `            ``# update back[i]``            ``back[i] ``=` `back[i ``+` `1``] ``+` `1``;` `    ``# Store the length of longest increasing``    ``# contiguous subarray``    ``ans ``=` `1``;` `    ``# Check whether first element is``    ``# contributing in subarray or not``    ``check_first ``=` `True``;` `    ``# Keep track of longest subarray when``    ``# first element is removed``    ``ans_first ``=` `1``;` `    ``for` `i ``in` `range``(``1``, n) :` `        ``# front[i] == 1 means contribution of``        ``# first element in max``        ``# length subarray has ended``        ``if` `(front[i] ``=``=` `1``) :``            ``check_first ``=` `True``;` `        ``ans_first ``=` `max``(ans_first, front[i]);` `    ``# First element contributes in the subarray``    ``if` `(check_first ``=``=` `False``) :``        ``ans_first ``-``=` `1``;` `    ``# Check whether last element is``    ``# contributing in subarray or not``    ``check_last ``=` `True``;` `    ``# Keep track of longest subarray when``    ``# last element is removed``    ``ans_last ``=` `1``;` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``) :``        ` `        ``# back[i] == 1 means contribution of``        ``# last element in max``        ``# length subarray has ended``        ``if` `(back[i] ``=``=` `1``) :``            ``check_last ``=` `True``;` `        ``ans_last ``=` `max``(ans_last, back[i]);` `    ``# Last element contributes in the subarray``    ``if` `(check_last ``=``=` `False``) :``        ``ans_last ``-``=` `1``;` `    ``# Update ans``    ``ans ``=` `max``(ans_first, ans_last);` `    ``# Calculating max length when``    ``# (i+1)th element is deleted``    ``for` `i ``in` `range``( n ``-` `2``) :``        ``if` `(arr[i] < arr[i ``+` `2``]) :``            ``ans ``=` `max``(ans, front[i] ``+` `back[i ``+` `2``]);` `    ``return` `ans;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``2``, ``1``, ``3``, ``1` `];``    ``n ``=` `len``(arr);``    ``print``(maxLenSubarr(arr, n));` `    ``# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG {` `// Function to find the maximum length of longest``// increasing contiguous subarray after removing``// exactly one element from array``static` `int` `maxLenSubarr(``int` `[]arr, ``int` `n)``{``    ``// Creating front[] and back[] arrays``    ``int` `[]front = ``new` `int``[n];``    ``int` `[]back = ``new` `int``[n];``    ``for` `(``int` `i = 0; i < n; i++) {``        ``front[i] = 1;``        ``back[i] = 1;``    ``}` `    ``// Calculating the front[]``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(arr[i] > arr[i - 1]) {` `            ``// Update front[i]``            ``front[i] = front[i - 1] + 1;``        ``}``    ``}` `    ``// Calculating the back[]``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``        ``if` `(arr[i] < arr[i + 1]) {` `            ``// update back[i]``            ``back[i] = back[i + 1] + 1;``        ``}``    ``}` `    ``// Store the length of longest increasing``    ``// contiguous subarray``    ``int` `ans = 1;` `    ``// Check whether first element is``    ``// contributing in subarray or not``    ``bool` `check_first = ``true``;` `    ``// Keep track of longest subarray when``    ``// first element is removed``    ``int` `ans_first = 1;` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// front[i] == 1 means contribution of``        ``// first element in max``        ``// length subarray has ended``        ``if` `(front[i] == 1) {``            ``check_first = ``true``;``        ``}` `        ``ans_first = Math.Max(ans_first, front[i]);``    ``}` `    ``// First element contributes in the subarray``    ``if` `(check_first == ``false``) {``        ``ans_first -= 1;``    ``}` `    ``// Check whether last element is``    ``// contributing in subarray or not``    ``bool` `check_last = ``true``;` `    ``// Keep track of longest subarray when``    ``// last element is removed``    ``int` `ans_last = 1;` `    ``for` `(``int` `i = n - 2; i >= 0; i--) {` `        ``// back[i] == 1 means contribution of``        ``// last element in max``        ``// length subarray has ended``        ``if` `(back[i] == 1) {``            ``check_last = ``true``;``        ``}``        ``ans_last = Math.Max(ans_last, back[i]);``    ``}` `    ``// Last element contributes in the subarray``    ``if` `(check_last == ``false``) {``        ``ans_last -= 1;``    ``}` `    ``// Update ans``    ``ans = Math.Max(ans_first, ans_last);` `    ``// Calculating max length when``    ``// (i+1)th element is deleted``    ``for` `(``int` `i = 0; i < n - 2; i++) {``        ``if` `(arr[i] < arr[i + 2]) {``            ``ans = Math.Max(ans,``                      ``front[i] + back[i + 2]);``        ``}``    ``}` `    ``return` `ans;``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args) {``        ` `        ``int` `[]arr = { 2, 1, 3, 1 };``        ``int` `n = arr.Length;``        ``Console.WriteLine(maxLenSubarr(arr, n));``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``
Output
`2`

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

My Personal Notes arrow_drop_up