# Check if a triplet of buildings can be selected such that the third building is taller than the first building and smaller than the second building

• Difficulty Level : Expert
• Last Updated : 04 Sep, 2021

Given an array arr[] consisting of N integers, where each array element represents the height of a building situated on the X co-ordinates, the task is to check if it is possible to select 3 buildings, such that the third selected building is taller than the first selected building and shorter than the second selected building.

Examples:

Input: arr[] = {4, 7, 11, 5, 13, 2}
Output: Yes
Explanation:
One possible way is to select the building at indices [0, 1, 3] with heights 4, 7 and 5 respectively.

Input: arr[] = {11, 11, 12, 9}
Output: No

Approach: The given problem can be solved using the Stack data structure. Follow the steps below to solve the problem:

• If N is less than 3, then print “No“.
• Initialize an array, say preMin[], to store the prefix minimum array of array arr[].
• Traverse the array arr[] and update preMin[i] as preMin[i] = min(preMin[i-1], arr[i]).
• Now, initialize a Stack, say stack, to store the elements from the ending in ascending order.
• Traverse the array arr[] in reverse using a variable, say i, and perform the following steps:
• After completing the above steps, if none of the above cases satisfy, then print “No“.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `// Function to check if it is possible` `// to select three buildings that` `// satisfy the given condition` `string recreationalSpot(``int` `arr[], ``int` `N)` `{`   `    ``if` `(N < 3) {` `        ``return` `"No"``;` `    ``}`   `    ``// Stores prefix min array` `    ``int` `preMin[N];` `    ``preMin = arr;`   `    ``// Iterate over the range [1, N-1]` `    ``for` `(``int` `i = 1; i < N; i++) {` `        ``preMin[i] = min(preMin[i - 1], arr[i]);` `    ``}`   `    ``// Stores the element from the` `    ``// ending in increasing order` `    ``stack<``int``> stack;`   `    ``// Iterate until j is greater than` `    ``// or equal to 0` `    ``for` `(``int` `j = N - 1; j >= 0; j--) {`   `        ``// If current array element is` `        ``// greater than the prefix min` `        ``// upto j` `        ``if` `(arr[j] > preMin[j]) {`   `            ``// Iterate while stack is not` `            ``// empty and top element is` `            ``// less than or equal to preMin[j]`   `            ``while` `(!stack.empty()` `                   ``&& stack.top() <= preMin[j]) {` `                ``// Remove the top element` `                ``stack.pop();` `            ``}`   `            ``// If stack is not empty and top` `            ``// element of the stack is less` `            ``// than the current element` `            ``if` `(!stack.empty() && stack.top() < arr[j]) {` `                ``return` `"Yes"``;` `            ``}` `            ``// Push the arr[j] in stack` `            ``stack.push(arr[j]);` `        ``}` `    ``}` `    ``// If none of the above case` `    ``// satisfy then return "No"` `    ``return` `"No"``;` `}`   `// Driver code` `int` `main()` `{` `    ``// Input` `    ``int` `arr[] = { 4, 7, 11, 5, 13, 2 };` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``cout << recreationalSpot(arr, size);` `}`

## Java

 `// Java implementation of the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to check if it is possible` `// to select three buildings that` `// satisfy the given condition` `static` `String recreationalSpot(``int` `arr[], ``int` `N)` `{` `    ``if` `(N < ``3``) ` `    ``{` `        ``return` `"No"``;` `    ``}`   `    ``// Stores prefix min array` `    ``int` `preMin[] = ``new` `int``[N];` `    ``preMin[``0``] = arr[``0``];`   `    ``// Iterate over the range [1, N-1]` `    ``for``(``int` `i = ``1``; i < N; i++) ` `    ``{` `        ``preMin[i] = Math.min(preMin[i - ``1``], arr[i]);` `    ``}`   `    ``// Stores the element from the` `    ``// ending in increasing order` `    ``Stack stack = ``new` `Stack();`   `    ``// Iterate until j is greater than` `    ``// or equal to 0` `    ``for``(``int` `j = N - ``1``; j >= ``0``; j--) ` `    ``{` `        `  `        ``// If current array element is` `        ``// greater than the prefix min` `        ``// upto j` `        ``if` `(arr[j] > preMin[j]) ` `        ``{` `            `  `            ``// Iterate while stack is not` `            ``// empty and top element is` `            ``// less than or equal to preMin[j]` `            ``while` `(stack.empty() == ``false` `&& ` `                   ``stack.peek() <= preMin[j])` `            ``{` `                `  `                ``// Remove the top element` `                ``stack.pop();` `            ``}`   `            ``// If stack is not empty and top` `            ``// element of the stack is less` `            ``// than the current element` `            ``if` `(stack.empty() == ``false` `&&` `                ``stack.peek() < arr[j]) ` `            ``{` `                ``return` `"Yes"``;` `            ``}` `            `  `            ``// Push the arr[j] in stack` `            ``stack.push(arr[j]);` `        ``}` `    ``}` `    `  `    ``// If none of the above case` `    ``// satisfy then return "No"` `    ``return` `"No"``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Input` `    ``int` `arr[] = { ``4``, ``7``, ``11``, ``5``, ``13``, ``2` `};` `    ``int` `size = arr.length;`   `    ``System.out.println(recreationalSpot(arr, size));` `}` `}`   `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python3 implementation of the above approach`   `# Function to check if it is possible` `# to select three buildings that` `# satisfy the given condition` `def` `recreationalSpot(arr, N):` `    `  `    ``if` `(N < ``3``):` `        ``return` `"No"`   `    ``# Stores prefix min array` `    ``preMin ``=` `[``0``] ``*` `N` `    ``preMin[``0``] ``=` `arr[``0``]`   `    ``# Iterate over the range [1, N-1]` `    ``for` `i ``in` `range``(``1``, N):` `        ``preMin[i] ``=` `min``(preMin[i ``-` `1``], arr[i])`   `    ``# Stores the element from the` `    ``# ending in increasing order` `    ``stack ``=` `[]`   `    ``# Iterate until j is greater than` `    ``# or equal to 0` `    ``for` `j ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):` `        `  `        ``# If current array element is` `        ``# greater than the prefix min` `        ``# upto j` `        ``if` `(arr[j] > preMin[j]):`   `            ``# Iterate while stack is not` `            ``# empty and top element is` `            ``# less than or equal to preMin[j]` `            ``while` `(``len``(stack) > ``0` `and` `                   ``stack[``-``1``] <``=` `preMin[j]):` `                       `  `                ``# Remove the top element` `                ``del` `stack[``-``1``]`   `            ``# If stack is not empty and top` `            ``# element of the stack is less` `            ``# than the current element` `            ``if` `(``len``(stack) > ``0` `and` `stack[``-``1``] < arr[j]):` `                ``return` `"Yes"`   `            ``# Push the arr[j] in stack` `            ``stack.append(arr[j])`   `    ``# If none of the above case` `    ``# satisfy then return "No"` `    ``return` `"No"`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Input` `    ``arr ``=`  `[ ``4``, ``7``, ``11``, ``5``, ``13``, ``2` `]` `    ``size ``=` `len``(arr)`   `    ``print` `(recreationalSpot(arr, size))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the above approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG{`   `// Function to check if it is possible` `// to select three buildings that` `// satisfy the given condition` `static` `String recreationalSpot(``int` `[]arr, ``int` `N)` `{` `    ``if` `(N < 3) ` `    ``{` `        ``return` `"No"``;` `    ``}`   `    ``// Stores prefix min array   ` `    ``int` `[]preMin = ``new` `int``[N];` `    ``preMin = arr;`   `    ``// Iterate over the range [1, N-1]` `    ``for``(``int` `i = 1; i < N; i++) ` `    ``{` `        ``preMin[i] = Math.Min(preMin[i - 1], arr[i]);` `    ``}`   `    ``// Stores the element from the` `    ``// ending in increasing order` `    ``Stack<``int``> stack = ``new` `Stack<``int``>();`   `    ``// Iterate until j is greater than` `    ``// or equal to 0` `    ``for``(``int` `j = N - 1; j >= 0; j--) ` `    ``{` `        `  `        ``// If current array element is` `        ``// greater than the prefix min` `        ``// upto j` `        ``if` `(arr[j] > preMin[j]) ` `        ``{` `            `  `            ``// Iterate while stack is not` `            ``// empty and top element is` `            ``// less than or equal to preMin[j]` `            ``while` `(stack.Count!=0 && ` `                   ``stack.Peek() <= preMin[j])` `            ``{` `                `  `                ``// Remove the top element` `                ``stack.Pop();` `            ``}`   `            ``// If stack is not empty and top` `            ``// element of the stack is less` `            ``// than the current element` `            ``if` `(stack.Count!=0 &&` `                ``stack.Peek() < arr[j]) ` `            ``{` `                ``return` `"Yes"``;` `            ``}` `            `  `            ``// Push the arr[j] in stack` `            ``stack.Push(arr[j]);` `        ``}` `    ``}` `    `  `    ``// If none of the above case` `    ``// satisfy then return "No"` `    ``return` `"No"``;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Input` `    ``int` `[]arr = { 4, 7, 11, 5, 13, 2 };` `    ``int` `size = arr.Length;`   `    ``Console.WriteLine(recreationalSpot(arr, size));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`Yes`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :