# Count triplets (i, j, k) in an array of distinct elements such that a[i] < a[j] > a[k] and i < j < k

Given an array **arr[]** consisting of **N **distinct integers, the task is to count the number of triplets **(i, j, k)** possible from the array **arr[]** such that **i < j < k** and **arr[i] < arr[j] > arr[k]**.

**Examples:**

Input:arr[] = {2, 3, 1, -1}Output:2Explanation:From the given array, all possible triplets satisfying the property (i, j, k) and arr[i] < arr[j] > arr[k] are:

(0, 1, 2):arr[0](= 2) < arr[1](= 3) > arr[2](= 1).(0, 1, 3):arr[0](= 2) < arr[1](= 3) > arr[3](= -1).Therefore, the count of triplets is 2.

Input:arr[] = {2, 3, 4, 6, 7, 9, 1, 12, 10, 8}Output:41

**Naive Approach:** The simplest approach to solve the problem is to traverse the given array and for each element **arr[i]**, the product of the count of smaller elements on the left side of **arr[i]** and the count of smaller elements on the right side of **arr[i]** gives the count of triplets for the element **arr[i]** as the middle element. The sum of all the counts obtained for each index is the required number of valid triplets.**Time Complexity:** O(N^{2})**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can also be optimized by finding the count of smaller elements using a Policy-based data structure (**PBDS)**. Follow the steps below to solve the problem:

- Initialize the variable, say
**ans**to**0**that stores the total number of possible pairs. - Initialize two containers of the Policy-based data structure, say
**P**and**Q**. - Initialize a vector of pairs
**V**, where**V[i]. first**and**V[i].second**stores the count of smaller elements on the left and the right side of every array element**arr[i]**. - Traverse the given array and for each element
**arr[i]**, update the value of**V[i].first**as**P.order_of_key(arr[i])**and insert**arr[i]**to set**P**. - Traverse the array from right to left and for each element
**arr[i]**, update the value of**V[i].first**as**P.order_of_key(arr[i])**and insert**arr[i]**to set**Q**. - Traverse the vector of pairs
**V**and add the value of**V[i].first * V[i].second**to the variable**ans**. - After completing the above steps, print the value of
**ans**as the total number of pairs.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` ` ` `#include <ext/pb_ds/assoc_container.hpp>` `#include <ext/pb_ds/tree_policy.hpp>` `#include <functional>` `#include <iostream>` `using` `namespace` `__gnu_pbds;` `using` `namespace` `std;` ` ` `// Function to find the count of triplets` `// satisfying the given conditions` `void` `findTriplets(` `int` `arr[], ` `int` `n)` `{` ` ` `// Stores the total count of pairs` ` ` `int` `ans = 0;` ` ` ` ` `// Declare the set` ` ` `tree<` `int` `, null_type, less<` `int` `>, rb_tree_tag,` ` ` `tree_order_statistics_node_update>` ` ` `p, q;` ` ` ` ` `// Declare the vector of pairs` ` ` `vector<pair<` `int` `, ` `int` `> > v(n);` ` ` ` ` `// Iterate over the array from` ` ` `// left to right` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` ` ` `// Find the index of element` ` ` `// in sorted array` ` ` `int` `index = p.order_of_key(arr[i]);` ` ` ` ` `// Assign to the left` ` ` `v[i].first = index;` ` ` ` ` `// Insert into the set` ` ` `p.insert(arr[i]);` ` ` `}` ` ` ` ` `// Iterate from right to left` ` ` `for` `(` `int` `i = n - 1; i >= 0; i--) {` ` ` ` ` `// Find the index of element` ` ` `// in the sorted array` ` ` `int` `index = q.order_of_key(arr[i]);` ` ` ` ` `// Assign to the right` ` ` `v[i].second = index;` ` ` ` ` `// Insert into the set` ` ` `q.insert(arr[i]);` ` ` `}` ` ` ` ` `// Traverse the vector of pairs` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `ans += (v[i].first * v[i].second);` ` ` `}` ` ` ` ` `// Print the total count` ` ` `cout << ans;` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 2, 3, 1, -1 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `findTriplets(arr, N);` ` ` ` ` `return` `0;` `}` |

**Output:**

2

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