Given an array A[0 … n-1] containing n positive integers, a subarray A[i … j] is bitonic if there is a k with i <= k <= j such that A[i] <= A[i + 1] … = A[k + 1] >= .. A[j – 1] > = A[j]. Write a function that takes an array as argument and returns the length of the maximum length bitonic subarray.
Expected time complexity of the solution is O(n)
Simple Examples
1) A[] = {12, 4, 78, 90, 45, 23}, the maximum length bitonic subarray is {4, 78, 90, 45, 23} which is of length 5.
2) A[] = {20, 4, 1, 2, 3, 4, 2, 10}, the maximum length bitonic subarray is {1, 2, 3, 4, 2} which is of length 5.
Extreme Examples
1) A[] = {10}, the single element is bitonic, so output is 1.
2) A[] = {10, 20, 30, 40}, the complete array itself is bitonic, so output is 4.
3) A[] = {40, 30, 20, 10}, the complete array itself is bitonic, so output is 4.
Solution
Let us consider the array {12, 4, 78, 90, 45, 23} to understand the solution.
1) Construct an auxiliary array inc[] from left to right such that inc[i] contains length of the nondecreasing subarray ending at arr[i].
For A[] = {12, 4, 78, 90, 45, 23}, inc[] is {1, 1, 2, 3, 1, 1}
2) Construct another array dec[] from right to left such that dec[i] contains length of nonincreasing subarray starting at arr[i].
For A[] = {12, 4, 78, 90, 45, 23}, dec[] is {2, 1, 1, 3, 2, 1}.
3) Once we have the inc[] and dec[] arrays, all we need to do is find the maximum value of (inc[i] + dec[i] – 1).
For {12, 4, 78, 90, 45, 23}, the max value of (inc[i] + dec[i] – 1) is 5 for i = 3.
// C++ program to find length of // the longest bitonic subarray #include <bits/stdc++.h> using namespace std;
int bitonic( int arr[], int n)
{ // Length of increasing subarray
// ending at all indexes
int inc[n];
// Length of decreasing subarray
// starting at all indexes
int dec[n];
int i, max;
// length of increasing sequence
// ending at first index is 1
inc[0] = 1;
// length of increasing sequence
// starting at first index is 1
dec[n-1] = 1;
// Step 1) Construct increasing sequence array
for (i = 1; i < n; i++)
inc[i] = (arr[i] >= arr[i-1])? inc[i-1] + 1: 1;
// Step 2) Construct decreasing sequence array
for (i = n-2; i >= 0; i--)
dec[i] = (arr[i] >= arr[i+1])? dec[i+1] + 1: 1;
// Step 3) Find the length of
// maximum length bitonic sequence
max = inc[0] + dec[0] - 1;
for (i = 1; i < n; i++)
if (inc[i] + dec[i] - 1 > max)
max = inc[i] + dec[i] - 1;
return max;
} /* Driver code */ int main()
{ int arr[] = {12, 4, 78, 90, 45, 23};
int n = sizeof (arr)/ sizeof (arr[0]);
cout << "nLength of max length Bitonic Subarray is " << bitonic(arr, n);
return 0;
} // This is code is contributed by rathbhupendra |
// C program to find length of the longest bitonic subarray #include<stdio.h> #include<stdlib.h> int bitonic( int arr[], int n)
{ int inc[n]; // Length of increasing subarray ending at all indexes
int dec[n]; // Length of decreasing subarray starting at all indexes
int i, max;
// length of increasing sequence ending at first index is 1
inc[0] = 1;
// length of increasing sequence starting at first index is 1
dec[n-1] = 1;
// Step 1) Construct increasing sequence array
for (i = 1; i < n; i++)
inc[i] = (arr[i] >= arr[i-1])? inc[i-1] + 1: 1;
// Step 2) Construct decreasing sequence array
for (i = n-2; i >= 0; i--)
dec[i] = (arr[i] >= arr[i+1])? dec[i+1] + 1: 1;
// Step 3) Find the length of maximum length bitonic sequence
max = inc[0] + dec[0] - 1;
for (i = 1; i < n; i++)
if (inc[i] + dec[i] - 1 > max)
max = inc[i] + dec[i] - 1;
return max;
} /* Driver program to test above function */ int main()
{ int arr[] = {12, 4, 78, 90, 45, 23};
int n = sizeof (arr)/ sizeof (arr[0]);
printf ( "nLength of max length Bitonic Subarray is %d" ,
bitonic(arr, n));
return 0;
} |
// Java program to find length of the longest bitonic subarray import java.io.*;
import java.util.*;
class Bitonic
{ static int bitonic( int arr[], int n)
{
int [] inc = new int [n]; // Length of increasing subarray ending
// at all indexes
int [] dec = new int [n]; // Length of decreasing subarray starting
// at all indexes
int max;
// Length of increasing sequence ending at first index is 1
inc[ 0 ] = 1 ;
// Length of increasing sequence starting at first index is 1
dec[n- 1 ] = 1 ;
// Step 1) Construct increasing sequence array
for ( int i = 1 ; i < n; i++)
inc[i] = (arr[i] >= arr[i- 1 ])? inc[i- 1 ] + 1 : 1 ;
// Step 2) Construct decreasing sequence array
for ( int i = n- 2 ; i >= 0 ; i--)
dec[i] = (arr[i] >= arr[i+ 1 ])? dec[i+ 1 ] + 1 : 1 ;
// Step 3) Find the length of maximum length bitonic sequence
max = inc[ 0 ] + dec[ 0 ] - 1 ;
for ( int i = 1 ; i < n; i++)
if (inc[i] + dec[i] - 1 > max)
max = inc[i] + dec[i] - 1 ;
return max;
}
/*Driver function to check for above function*/
public static void main (String[] args)
{
int arr[] = { 12 , 4 , 78 , 90 , 45 , 23 };
int n = arr.length;
System.out.println( "Length of max length Bitonic Subarray is "
+ bitonic(arr, n));
}
} /* This code is contributed by Devesh Agrawal */ |
# Python program to find length of the longest bitonic subarray def bitonic(arr, n):
# Length of increasing subarray ending at all indexes
inc = [ None ] * n
# Length of decreasing subarray starting at all indexes
dec = [ None ] * n
# length of increasing sequence ending at first index is 1
inc[ 0 ] = 1
# length of increasing sequence starting at first index is 1
dec[n - 1 ] = 1
# Step 1) Construct increasing sequence array
for i in range (n):
if arr[i] > = arr[i - 1 ]:
inc[i] = inc[i - 1 ] + 1
else :
inc[i] = 1
# Step 2) Construct decreasing sequence array
for i in range (n - 2 , - 1 , - 1 ):
if arr[i] > = arr[i - 1 ]:
dec[i] = inc[i - 1 ] + 1
else :
dec[i] = 1
# Step 3) Find the length of maximum length bitonic sequence
max = inc[ 0 ] + dec[ 0 ] - 1
for i in range (n):
if inc[i] + dec[i] - 1 > max :
max = inc[i] + dec[i] - 1
return max
# Driver program to test above function arr = [ 12 , 4 , 78 , 90 , 45 , 23 ]
n = len (arr)
print ( "nLength of max length Bitonic Subarray is " ,bitonic(arr, n))
|
// C# program to find length of the // longest bitonic subarray using System;
class GFG
{ static int bitonic( int []arr, int n)
{
// Length of increasing subarray ending
// at all indexes
int [] inc = new int [n];
// Length of decreasing subarray starting
// at all indexes
int [] dec = new int [n];
int max;
// Length of increasing sequence
// ending at first index is 1
inc[0] = 1;
// Length of increasing sequence
// starting at first index is 1
dec[n - 1] = 1;
// Step 1) Construct increasing sequence array
for ( int i = 1; i < n; i++)
inc[i] = (arr[i] >= arr[i - 1]) ?
inc[i - 1] + 1: 1;
// Step 2) Construct decreasing sequence array
for ( int i = n - 2; i >= 0; i--)
dec[i] = (arr[i] >= arr[i + 1]) ?
dec[i + 1] + 1: 1;
// Step 3) Find the length of maximum
// length bitonic sequence
max = inc[0] + dec[0] - 1;
for ( int i = 1; i < n; i++)
if (inc[i] + dec[i] - 1 > max)
max = inc[i] + dec[i] - 1;
return max;
}
// Driver function
public static void Main ()
{
int []arr = {12, 4, 78, 90, 45, 23};
int n = arr.Length;
Console.Write( "Length of max length Bitonic Subarray is "
+ bitonic(arr, n));
}
} // This code is contributed by Sam007 |
<?php // PHP program to find length of // the longest bitonic subarray function bitonic( $arr , $n )
{ $i ; $max ;
// length of increasing sequence
// ending at first index is 1
$inc [0] = 1;
// length of increasing sequence
// starting at first index is 1
$dec [ $n - 1] = 1;
// Step 1) Construct increasing
// sequence array
for ( $i = 1; $i < $n ; $i ++)
$inc [ $i ] = ( $arr [ $i ] >= $arr [ $i - 1]) ?
$inc [ $i - 1] + 1: 1;
// Step 2) Construct decreasing
// sequence array
for ( $i = $n - 2; $i >= 0; $i --)
$dec [ $i ] = ( $arr [ $i ] >= $arr [ $i + 1]) ?
$dec [ $i + 1] + 1: 1;
// Step 3) Find the length of
// maximum length bitonic sequence
$max = $inc [0] + $dec [0] - 1;
for ( $i = 1; $i < $n ; $i ++)
if ( $inc [ $i ] + $dec [ $i ] - 1 > $max )
$max = $inc [ $i ] + $dec [ $i ] - 1;
return $max ;
} // Driver Code $arr = array (12, 4, 78, 90, 45, 23);
$n = sizeof( $arr );
echo "Length of max length Bitonic " .
"Subarray is " , bitonic( $arr , $n );
// This code is contributed by aj_36 ?> |
<script> // Javascript program to find length of the
// longest bitonic subarray
function bitonic(arr, n)
{
// Length of increasing subarray ending
// at all indexes
let inc = new Array(n);
// Length of decreasing subarray starting
// at all indexes
let dec = new Array(n);
let max;
// Length of increasing sequence
// ending at first index is 1
inc[0] = 1;
// Length of increasing sequence
// starting at first index is 1
dec[n - 1] = 1;
// Step 1) Construct increasing sequence array
for (let i = 1; i < n; i++)
inc[i] = (arr[i] >= arr[i - 1]) ? inc[i - 1] + 1: 1;
// Step 2) Construct decreasing sequence array
for (let i = n - 2; i >= 0; i--)
dec[i] = (arr[i] >= arr[i + 1]) ? dec[i + 1] + 1: 1;
// Step 3) Find the length of maximum
// length bitonic sequence
max = inc[0] + dec[0] - 1;
for (let i = 1; i < n; i++)
if (inc[i] + dec[i] - 1 > max)
max = inc[i] + dec[i] - 1;
return max;
}
let arr = [12, 4, 78, 90, 45, 23];
let n = arr.length;
document.write( "Length of max length Bitonic Subarray is " + bitonic(arr, n));
</script> |
nLength of max length Bitonic Subarray is 5
Output :
Length of max length Bitonic Subarray is 5
Time Complexity : O(n)
Auxiliary Space : O(n)
Maximum Length Bitonic Subarray | Set 2 (O(n) time and O(1) Space)
As an exercise, extend the above implementation to print the longest bitonic subarray also. The above implementation only returns the length of such subarray.