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 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
# 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
<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>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Maximum subarray sum possible after removing at most K array elements Given an array arr[] of size N and an integer K, the task is to find the maximum subarray sum by removing at most K elements from the array. Examples: Input: arr[] = { -2, 1, 3, -2, 4, -7, 20 }, K = 1 Output: 26 Explanation: Removing arr[5] from the array modifies arr[] to { -2, 1, 3, -2, 4, 20 } Su
15+ min read
Maximize length of Non-Decreasing Subsequence by reversing at most one Subarray Given a binary array arr[], the task is to find the maximum possible length of non-decreasing subsequence that can be generated by reversing a subarray at most once. Examples: Input: arr[] = {0, 1, 0, 1} Output: 4 Explanation: After reversing the subarray from index [2, 3], the array modifies to {0,
9 min read
Maximize the maximum subarray sum after removing atmost one element Given an array arr[] of N integers, the task is to find the maximum sum of a subarray with at most one deletion allowed. The size of subarray to be considered should be at least 1.Examples: Input: arr[] = {1, 2, 3, -2, 3} Output: 9 The maximum sub-array sum is given by the sub-array {2, 3, -2, 3} He
2 min read
Maximize the maximum subarray sum after removing atmost one element Given an array arr[] of N integers, the task is to find the maximum sum of a subarray with at most one deletion allowed. The size of subarray to be considered should be at least 1.Examples: Input: arr[] = {1, 2, 3, -2, 3} Output: 9 The maximum sub-array sum is given by the sub-array {2, 3, -2, 3} He
2 min read
Maximize length of Subarray of 1's after removal of a pair of consecutive Array elements Given a binary array arr[] consisting of N elements, the task is to find the maximum possible length of a subarray of only 1’s, after deleting a single pair of consecutive array elements. If no such subarray exists, print -1. Examples: Input: arr[] = {1, 1, 1, 0, 0, 1} Output: 4 Explanation: Removal
15+ min read
Queries to find the maximum array element after removing elements from a given range Given an array arr[] and an array Q[][] consisting of queries of the form of {L, R}, the task for each query is to find the maximum array element after removing array elements from the range of indices [L, R]. If the array becomes empty after removing the elements from given range of indices, then p
10 min read