 GeeksforGeeks App
Open App Browser
Continue

# Maximum Length Bitonic Subarray | Set 1 (O(n) time and O(n) space)

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++

 `// C++ program to find length of``// the longest bitonic subarray``#include ``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 = 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 + dec - 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);``    ``cout << ``"nLength of max length Bitonic Subarray is "` `<< bitonic(arr, n);``    ``return` `0;``}` `// This is code is contributed by rathbhupendra`

## C

 `// C program to find length of the longest bitonic subarray``#include``#include` `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 = 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 + dec - 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);``    ``printf``(``"nLength of max length Bitonic Subarray is %d"``,``            ``bitonic(arr, n));``    ``return` `0;``}`

## Java

 `// 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 */`

## Python3

 `# 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#

 `// 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 = 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 + dec - 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

 `= ``\$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`` + ``\$dec`` - 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``?>`

## Javascript

 ``

Output

`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.