计算不同元素数组中的三元组(i，j，k)，以便a [i] <a [j]> a [k]和i <j <k

给定由N个不同整数组成的数组arr [] ，任务是计算数组arr []中可能的三元组(i，j，k)的数量，以使i 并且arr [i] arr [k] 。

例子：

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

1. (0, 1, 2): arr[0](= 2) < arr[1](= 3) > arr[2](= 1).
2. (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

天真的方法：解决问题的最简单方法是遍历给定的数组，对于每个元素arr [i] ，其元素为arr [i]左侧较小元素的数量与数组中较小元素的数量的乘积arr [i]的右侧给出了元素arr [i]作为中间元素的三元组计数。每个索引获得的所有计数的总和是有效三元组的必需数量。
时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：还可以通过使用基于策略的数据结构( PBDS)查找较小元素的数量来优化上述方法。请按照以下步骤解决问题：

• 初始化变量，将ans表示为0 ，以存储可能的对总数。
• 初始化两个基于策略的数据结构的容器，例如P和Q。
• 初始化对V的向量，其中V [i]。 first和V [i] .second在每个数组元素arr [i]的左侧和右侧存储较小元素的计数。
• 遍历给定数组，并对每个元素arr [i] ，将V [i]。首先更新为P.order_of_key(arr [i])的值，然后插入arr [i]来设置P。
• 从右到左遍历数组，对于每个元素arr [i] ，将V [i]的值更新为P.order_of_key(arr [i])，然后插入arr [i]设置Q。
• 遍历对V的向量，并将V [i] .first * V [i] .second的值添加到变量ans 。
• 完成上述步骤后，将ans的值打印为对的总数。

下面是上述方法的实现：

C++

// C++ program for the above approach
  
#include 
#include 
#include 
#include 
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, rb_tree_tag,
         tree_order_statistics_node_update>
        p, q;
  
    // Declare the vector of pairs
    vector > 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;
}

输出：

2

时间复杂度： O(N * log N)
辅助空间： O(N)