Related Articles
Longest Subarrays having each Array element as the maximum
• Difficulty Level : Hard
• Last Updated : 10 May, 2021

Given an array arr[] of length N, the task is to find the longest subarray for each array element arr[i], which contains arr[i] as the maximum.

Examples:

Input: arr[] = {1, 2, 3, 0, 1}
Output: 1 2 5 1 2
Explanation:
The longest subarray having arr as the largest is {1}
The longest subarray having arr as the largest is {1, 2}
The longest subarray having arr as the largest is {1, 2, 3, 0, 1}
The longest subarray having arr as the largest is {0}
The longest subarray having arr[4 as the largest is {0, 1}
Input: arr[] = {3, 3, 3, 1, 6, 2}
Output: 4 4 4 1 6 1

Approach: The idea is to use Two Pointer technique to solve the problem:

• Initialize two pointers, left and right. such that for every element arr[i], the left points to indices [i – 1, 0] to find elements smaller than or equal to arr[i] in a contiguous manner. The moment an element larger than arr[i] is found, the pointer stops.
• Similarly, right points to indices [i + 1, n – 1] to find elements smaller than or equal to arr[i] in a contiguous manner, and stops on finding any element larger than arr[i].
• Therefore, the largest contiguous subarray where arr[i] is largest is of length 1 + right – left.
• Repeat the above steps for every array element.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum length of``// Subarrays for each element of the array``// having it as the maximum``void` `solve(``int` `n, ``int` `arr[])``{``    ``int` `i, ans = 0;``    ``for` `(i = 0; i < n; i++) {` `        ``// Initialize the bounds``        ``int` `left = max(i - 1, 0);``        ``int` `right = min(n - 1, i + 1);` `        ``// Iterate to find greater``        ``// element on the left``        ``while` `(left >= 0) {` `            ``// If greater element is found``            ``if` `(arr[left] > arr[i]) {``                ``left++;``                ``break``;``            ``}` `            ``// Decrement left pointer``            ``left--;``        ``}` `        ``// If boundary is exceeded``        ``if` `(left < 0)``            ``left++;` `        ``// Iterate to find greater``        ``// element on the right``        ``while` `(right < n) {` `            ``// If greater element is found``            ``if` `(arr[right] > arr[i]) {``                ``right--;``                ``break``;``            ``}``            ``// Increment right pointer``            ``right++;``        ``}` `        ``// If boundary is exceeded``        ``if` `(right >= n)``            ``right--;` `        ``// Length of longest subarray where``        ``// arr[i] is the largest``        ``ans = 1 + right - left;` `        ``// Print the answer``        ``cout << ans << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 2, 1 };``    ``int` `n = ``sizeof` `arr / ``sizeof` `arr;` `    ``solve(n, arr);` `    ``return` `0;``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Function to find the maximum length of``// Subarrays for each element of the array``// having it as the maximum``static` `void` `solve(``int` `n, ``int` `arr[])``{``    ``int` `i, ans = ``0``;``    ``for` `(i = ``0``; i < n; i++)``    ``{` `        ``// Initialize the bounds``        ``int` `left = Math.max(i - ``1``, ``0``);``        ``int` `right = Math.min(n - ``1``, i + ``1``);` `        ``// Iterate to find greater``        ``// element on the left``        ``while` `(left >= ``0``)``        ``{` `            ``// If greater element is found``            ``if` `(arr[left] > arr[i])``            ``{``                ``left++;``                ``break``;``            ``}` `            ``// Decrement left pointer``            ``left--;``        ``}` `        ``// If boundary is exceeded``        ``if` `(left < ``0``)``            ``left++;` `        ``// Iterate to find greater``        ``// element on the right``        ``while` `(right < n)``        ``{` `            ``// If greater element is found``            ``if` `(arr[right] > arr[i])``            ``{``                ``right--;``                ``break``;``            ``}``          ` `            ``// Increment right pointer``            ``right++;``        ``}` `        ``// If boundary is exceeded``        ``if` `(right >= n)``            ``right--;` `        ``// Length of longest subarray where``        ``// arr[i] is the largest``        ``ans = ``1` `+ right - left;` `        ``// Print the answer``        ``System.out.print(ans + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``4``, ``2``, ``1` `};``    ``int` `n = arr.length;` `    ``solve(n, arr);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the maximum length of``# Subarrays for each element of the array``# having it as the maximum``def` `solve(n, arr):``    ` `    ``ans ``=` `0``    ` `    ``for` `i ``in` `range``(n):``        ` `        ``# Inititalise the bounds``        ``left ``=` `max``(i ``-` `1``, ``0``)``        ``right ``=` `min``(n ``-` `1``, i ``+` `1``)``        ` `        ``# Iterate to find greater``        ``# element on the left``        ``while` `left >``=` `0``:``            ` `            ``# If greater element is found``            ``if` `arr[left] > arr[i]:``                ``left ``+``=` `1``                ``break``                ` `            ``# Decrement left pointer``            ``left ``-``=` `1``            ` `        ``# If boundary is exceeded``        ``if` `left < ``0``:``            ``left ``+``=` `1``            ` `        ``# Iterate to find greater``        ``# element on the right``        ``while` `right < n:``            ` `            ``# If greater element is found``            ``if` `arr[right] > arr[i]:``                ``right ``-``=` `1``                ``break``            ` `            ``# Increment right pointer``            ``right ``+``=` `1``        ` `        ``# if boundary is exceeded``        ``if` `right >``=` `n:``            ``right ``-``=` `1``            ` `        ``# Length of longest subarray where``        ``# arr[i] is the largest``        ``ans ``=` `1` `+` `right ``-` `left``        ` `        ``# Print the answer``        ``print``(ans, end ``=` `" "``)``        ` `# Driver code``arr ``=` `[ ``4``, ``2``, ``1` `]``n ``=` `len``(arr)` `solve(n, arr)``    ` `# This code is contributed by Stuti Pathak`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG{` `// Function to find the maximum length of``// Subarrays for each element of the array``// having it as the maximum``static` `void` `solve(``int` `n, ``int` `[]arr)``{``    ``int` `i, ans = 0;``    ``for` `(i = 0; i < n; i++)``    ``{` `        ``// Initialize the bounds``        ``int` `left = Math.Max(i - 1, 0);``        ``int` `right = Math.Min(n - 1, i + 1);` `        ``// Iterate to find greater``        ``// element on the left``        ``while` `(left >= 0)``        ``{` `            ``// If greater element is found``            ``if` `(arr[left] > arr[i])``            ``{``                ``left++;``                ``break``;``            ``}` `            ``// Decrement left pointer``            ``left--;``        ``}` `        ``// If boundary is exceeded``        ``if` `(left < 0)``            ``left++;` `        ``// Iterate to find greater``        ``// element on the right``        ``while` `(right < n)``        ``{` `            ``// If greater element is found``            ``if` `(arr[right] > arr[i])``            ``{``                ``right--;``                ``break``;``            ``}``          ` `            ``// Increment right pointer``            ``right++;``        ``}` `        ``// If boundary is exceeded``        ``if` `(right >= n)``            ``right--;` `        ``// Length of longest subarray where``        ``// arr[i] is the largest``        ``ans = 1 + right - left;` `        ``// Print the answer``        ``Console.Write(ans + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 4, 2, 1 };``    ``int` `n = arr.Length;` `    ``solve(n, arr);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
`3 2 1`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up