Check whether there exists a triplet (i, j, k) such that arr[i] < arr[k] < arr[j] for i < j < k

Given an array arr[], the task is to check that if there exist a triplet (i, j, k) such that arr[i]<arr[k]<arr[j] and i<j<k then print Yes else print No.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: No
Explanation:
There is no such sub-sequence such that arr[i] < arr[k] < arr[j]

Input: arr[] = {3, 1, 5, 0, 4}
Output: Yes
Explanation:
There exist a triplet (3, 5, 4) which is arr[i] < arr[k] < arr[j]

Naive Approach: The idea is to generate all possible triplets and if any triplets satisfy the given conditions the print Yes else print No
Time Complexity: O(N3
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach the idea is to use the stack to keep the track of the smaller elements in the right of every element in the array arr[]. Below are the steps:

• Traverse the array from the end and maintain a stack which stores the element in the decreasing order.
• To maintain the stack in decreasing order, pop the elements which are smaller than the current element. Then mark the popped element as the third element of the triplet.
• While traversing the array in reverse if any element is less than the last popped element(which is marked as the third element of the triplet). Then their exist a triplet which satisfy the given condition and print Yes.
• Otherwise print No.

Below is the implementation of the above approach:

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to check if there exist ` `// triplet in the array such that ` `// i < j < k and arr[i] < arr[k] < arr[j] ` `bool` `findTriplet(vector<``int``>& arr) ` `{ ` `    ``int` `n = arr.size(); ` `    ``stack<``int``> st; ` ` `  `    ``// Initialize the heights of h1 and h2 ` `    ``// to INT_MAX and INT_MIN respectively ` `    ``int` `h3 = INT_MIN, h1 = INT_MAX; ` `    ``for` `(``int` `i = n - 1; i >= 0; i--) { ` ` `  `        ``// Store the current element as h1 ` `        ``h1 = arr[i]; ` ` `  `        ``// If the element at top of stack ` `        ``// is less than the current element ` `        ``// then pop the stack top ` `        ``// and keep updating the value of h3 ` `        ``while` `(!st.empty() ` `            ``&& st.top() < arr[i]) { ` ` `  `            ``h3 = st.top(); ` `            ``st.pop(); ` `        ``} ` ` `  `        ``// Push the current element ` `        ``// on the stack ` `        ``st.push(arr[i]); ` ` `  `        ``// If current element is less ` `        ``// than h3, then we found such ` `        ``// triplet and return true ` `        ``if` `(h1 < h3) { ` `            ``return` `true``; ` `        ``} ` `    ``} ` ` `  `    ``// No triplet found, hence return false ` `    ``return` `false``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given array ` `    ``vector<``int``> arr = { 4, 7, 5, 6 }; ` ` `  `    ``// Function Call ` `    ``if` `(findTriplet(arr)) { ` `        ``cout << ``" Yes"` `<< ``'\n'``; ` `    ``} ` `    ``else` `{ ` `        ``cout << ``" No"` `<< ``'\n'``; ` `    ``} ` `    ``return` `0; ` `} `

 `// Java program for the above approach  ` `import` `java.util.*;  ` ` `  `class` `GFG{ ` `     `  `// Function to check if there exist  ` `// triplet in the array such that  ` `// i < j < k and arr[i] < arr[k] < arr[j]  ` `public` `static` `boolean` `findTriplet(``int``[] arr)  ` `{  ` `    ``int` `n = arr.length; ` `    ``Stack st = ``new` `Stack<>(); ` ` `  `    ``// Initialize the heights of h1 and h2  ` `    ``// to INT_MAX and INT_MIN respectively  ` `    ``int` `h3 = Integer.MIN_VALUE; ` `    ``int` `h1 = Integer.MAX_VALUE;  ` ` `  `    ``for``(``int` `i = n - ``1``; i >= ``0``; i--)  ` `    ``{  ` `         `  `        ``// Store the current element as h1  ` `        ``h1 = arr[i];  ` ` `  `        ``// If the element at top of stack  ` `        ``// is less than the current element  ` `        ``// then pop the stack top  ` `        ``// and keep updating the value of h3  ` `        ``while` `(!st.empty() && st.peek() < arr[i]) ` `        ``{  ` `            ``h3 = st.peek();  ` `            ``st.pop();  ` `        ``}  ` ` `  `        ``// Push the current element  ` `        ``// on the stack  ` `        ``st.push(arr[i]);  ` ` `  `        ``// If current element is less  ` `        ``// than h3, then we found such  ` `        ``// triplet and return true  ` `        ``if` `(h1 < h3)  ` `        ``{  ` `            ``return` `true``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// No triplet found, hence return false  ` `    ``return` `false``;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given array  ` `    ``int` `arr[] = { ``4``, ``7``, ``5``, ``6` `};  ` ` `  `    ``// Function call  ` `    ``if` `(findTriplet(arr)) ` `    ``{  ` `        ``System.out.println(``"Yes"``); ` `    ``}  ` `    ``else` `    ``{  ` `        ``System.out.println(``"No"``);  ` `    ``}  ` `} ` `} ` ` `  `// This code is contributed by divyeshrabadiya07 `

 `# Python3 program for the above approach ` `import` `sys ` ` `  `# Function to check if there exist ` `# triplet in the array such that ` `# i < j < k and arr[i] < arr[k] < arr[j] ` `def` `findTriplet(arr): ` `    ``n ``=` `len``(arr) ` `    ``st ``=` `[] ` ` `  `    ``# Initialize the heights of h1 and h3 ` `    ``# to INT_MAX and INT_MIN respectively ` `    ``h3 ``=` `-``sys.maxsize ``-` `1` `    ``h1 ``=` `sys.maxsize ` `     `  `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``): ` ` `  `        ``# Store the current element as h1 ` `        ``h1 ``=` `arr[i] ` ` `  `        ``# If the element at top of stack ` `        ``# is less than the current element ` `        ``# then pop the stack top ` `        ``# and keep updating the value of h3 ` `        ``while` `(``len``(st) > ``0` `and` `st[``-``1``] < arr[i]): ` `            ``h3 ``=` `st[``-``1``] ` `            ``del` `st[``-``1``] ` ` `  `        ``# Push the current element ` `        ``# on the stack ` `        ``st.append(arr[i]) ` ` `  `        ``# If current element is less ` `        ``# than h3, then we found such ` `        ``# triplet and return true ` `        ``if` `(h1 < h3): ` `            ``return` `True` `         `  `    ``# No triplet found, hence  ` `    ``# return false ` `    ``return` `False` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Given array ` `    ``arr ``=` `[ ``4``, ``7``, ``5``, ``6` `] ` ` `  `    ``# Function Call ` `    ``if` `(findTriplet(arr)): ` `        ``print``(``"Yes"``) ` `    ``else``: ` `        ``print``(``"No"``) ` ` `  `# This code is contributed by mohit kumar 29 `

 `// C# program for the above approach  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` `     `  `// Function to check if there exist  ` `// triplet in the array such that  ` `// i < j < k and arr[i] < arr[k] < arr[j]  ` `public` `static` `bool` `findTriplet(``int``[] arr)  ` `{  ` `    ``int` `n = arr.Length; ` `    ``Stack<``int``> st = ``new` `Stack<``int``>(); ` ` `  `    ``// Initialize the heights of h1 and h2  ` `    ``// to INT_MAX and INT_MIN respectively  ` `    ``int` `h3 = ``int``.MinValue; ` `    ``int` `h1 = ``int``.MaxValue;  ` ` `  `    ``for``(``int` `i = n - 1; i >= 0; i--)  ` `    ``{  ` `         `  `        ``// Store the current element as h1  ` `        ``h1 = arr[i];  ` ` `  `        ``// If the element at top of stack  ` `        ``// is less than the current element  ` `        ``// then pop the stack top  ` `        ``// and keep updating the value of h3  ` `        ``while` `(st.Count != 0 && st.Peek() < arr[i]) ` `        ``{  ` `            ``h3 = st.Peek();  ` `            ``st.Pop();  ` `        ``}  ` ` `  `        ``// Push the current element  ` `        ``// on the stack  ` `        ``st.Push(arr[i]);  ` ` `  `        ``// If current element is less  ` `        ``// than h3, then we found such  ` `        ``// triplet and return true  ` `        ``if` `(h1 < h3)  ` `        ``{  ` `            ``return` `true``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// No triplet found, hence return false  ` `    ``return` `false``;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `     `  `    ``// Given array  ` `    ``int` `[]arr = { 4, 7, 5, 6 };  ` ` `  `    ``// Function call  ` `    ``if` `(findTriplet(arr)) ` `    ``{  ` `        ``Console.WriteLine(``"Yes"``); ` `    ``}  ` `    ``else` `    ``{  ` `        ``Console.WriteLine(``"No"``);  ` `    ``}  ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992`

Output:
```Yes
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Article Tags :
Practice Tags :