Count of Array elements greater than all elements on its left and at least K elements on its right

#include <iostream>
#include <vector>

using namespace std;

int countElements(vector<int>& A, int K) {
    int count = 0;
    int n = A.size();

    // Traverse the array
    for (int i = 0; i < n; i++) {
        bool greaterLeft = true;
        int smallerRightCount = 0;

        // Check if current element is greater than all elements to its left
        for (int j = 0; j < i; j++) {
            if (A[j] >= A[i]) {
                greaterLeft = false;
                break;
            }
        }

        // If current element is greater than all elements to its left
        if (greaterLeft) {
            // Count number of elements smaller than current element to its right
            for (int j = i + 1; j < n; j++) {
                if (A[j] < A[i]) {
                    smallerRightCount++;
                }
            }

            // If there are at least K elements smaller than current element to its right
            if (smallerRightCount >= K) {
                count++;
            }
        }
    }

    return count;
}

int main() {
    // Sample Inputs
    vector<int> A1 = { 2, 5, 1, 7, 3, 4, 0 };
    int K1 = 3;
    cout << countElements(A1, K1) << endl; // Output: 2

    vector<int> A2 = { 11, 2, 4, 7, 5, 9, 6, 3 };
    int K2 = 2;
    cout << countElements(A2, K2) << endl; // Output: 1

    return 0;
}

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Structure of an AVL Tree Node
struct node {
    int key;
    struct node* left;
    struct node* right;
    int height;
    // Size of the tree rooted
    // with this node
    int size;
};

// Utility function to get maximum
// of two integers
int max(int a, int b);

// Utility function to get height
// of the tree rooted with N
int height(struct node* N)
{
    if (N == NULL)
        return 0;
    return N->height;
}

// Utility function to find size of
// the tree rooted with N
int size(struct node* N)
{
    if (N == NULL)
        return 0;
    return N->size;
}

// Utility function to get maximum
// of two integers
int max(int a, int b)
{
    return (a > b) ? a : b;
}

// Helper function to allocates a
// new node with the given key
struct node* newNode(int key)
{
    struct node* node
        = (struct node*)
            malloc(sizeof(struct node));
    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 1;
    node->size = 1;
    return (node);
}

// Utility function to right rotate
// subtree rooted with y
struct node* rightRotate(struct node* y)
{
    struct node* x = y->left;
    struct node* T2 = x->right;

    // Perform rotation
    x->right = y;
    y->left = T2;

    // Update heights
    y->height = max(height(y->left),
                    height(y->right))
                + 1;
    x->height = max(height(x->left),
                    height(x->right))
                + 1;

    // Update sizes
    y->size = size(y->left)
              + size(y->right) + 1;
    x->size = size(x->left)
              + size(x->right) + 1;

    // Return new root
    return x;
}

// Utility function to left rotate
// subtree rooted with x
struct node* leftRotate(struct node* x)
{
    struct node* y = x->right;
    struct node* T2 = y->left;

    // Perform rotation
    y->left = x;
    x->right = T2;

    // Update heights
    x->height = max(height(x->left),
                    height(x->right))
                + 1;
    y->height = max(height(y->left),
                    height(y->right))
                + 1;

    // Update sizes
    x->size = size(x->left)
              + size(x->right) + 1;
    y->size = size(y->left)
              + size(y->right) + 1;

    // Return new root
    return y;
}

// Function to obtain Balance factor
// of node N
int getBalance(struct node* N)
{
    if (N == NULL)
        return 0;

    return height(N->left)
           - height(N->right);
}

// Function to insert a new key to the
// tree rooted with node
struct node* insert(struct node* node, int key,
                    int* count)
{
    // Perform the normal BST rotation
    if (node == NULL)
        return (newNode(key));

    if (key < node->key)
        node->left
            = insert(node->left, key, count);
    else {
        node->right
            = insert(node->right, key, count);

        // Update count of smaller elements
        *count = *count + size(node->left) + 1;
    }

    // Update height and size of the ancestor
    node->height = max(height(node->left),
                       height(node->right))
                   + 1;
    node->size = size(node->left)
                 + size(node->right) + 1;

    // Get the balance factor of the ancestor
    int balance = getBalance(node);

    // Left Left Case
    if (balance > 1 && key < node->left->key)
        return rightRotate(node);

    // Right Right Case
    if (balance < -1 && key > node->right->key)
        return leftRotate(node);

    // Left Right Case
    if (balance > 1 && key > node->left->key) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    // Right Left Case
    if (balance < -1 && key < node->right->key) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

// Function to generate an array which contains
// count of smaller elements on the right
void constructLowerArray(int arr[],
                         int countSmaller[],
                         int n)
{
    int i, j;
    struct node* root = NULL;

    for (i = 0; i < n; i++)
        countSmaller[i] = 0;

    // Insert all elements in the AVL Tree
    // and get the count of smaller elements
    for (i = n - 1; i >= 0; i--) {
        root = insert(root, arr[i],
                      &countSmaller[i]);
    }
}

// Function to find the number
// of elements which are greater
// than all elements on its left
// and K elements on its right
int countElements(int A[], int n, int K)
{

    int count = 0;

    // Stores the count of smaller
    // elements on its right
    int* countSmaller
        = (int*)malloc(sizeof(int) * n);
    constructLowerArray(A, countSmaller, n);

    int maxi = INT_MIN;
    for (int i = 0; i <= (n - K - 1); i++) {
        if (A[i] > maxi && countSmaller[i] >= K) {
            count++;
            maxi = A[i];
        }
    }

    return count;
}

// Driver Code
int main()
{

    int A[] = { 2, 5, 1, 7, 3, 4, 0 };
    int n = sizeof(A) / sizeof(int);
    int K = 3;

    cout << countElements(A, n, K);

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

class FenwickTree {
private:
    int size;
    vector<int> tree;

public:
    FenwickTree(int size)
        : size(size)
        , tree(size + 1, 0)
    {
    }

    void update(int index, int increment)
    {
        while (index <= size) {
            tree[index] += increment;
            index += index & -index;
        }
    }

    int query(int index)
    {
        int sum = 0;
        while (index > 0) {
            sum += tree[index];
            index -= index & -index;
        }
        return sum;
    }
};

int count_elements_greater_than_left_and_k_right(
    vector<int>& A, int K)
{
    int n = A.size();
    if (n == 0)
        return 0;

    // Transform A to rank based on value to fit in Fenwick
    // Tree
    map<int, int> rank;
    for (int i = 0; i < n; i++) {
        rank[A[i]] = i + 1;
    }
    FenwickTree fenwick(rank.size());

    // Array to store the count of smaller elements to the
    // right for each element
    vector<int> smaller_count_right(n, 0);

    // Populate smaller_count_right using Fenwick Tree
    for (int i = n - 1; i >= 0; i--) {
        int pos = rank[A[i]];
        smaller_count_right[i]
            = fenwick.query(rank.size() - 1)
              - fenwick.query(pos);
        fenwick.update(pos, 1);
    }

    // Count valid elements
    int count = 0;
    int max_left = INT_MIN;
    for (int i = 0; i < n; i++) {
        if (A[i] > max_left
            && smaller_count_right[i] >= K) {
            count++;
        }
        max_left = max(max_left, A[i]);
    }

    return count;
}

int main()
{
    vector<int> A = { 2, 5, 1, 7, 3, 4, 0 };
    int K = 3;
    cout << count_elements_greater_than_left_and_k_right(A,
                                                         K)
         << endl; // Output: 2
    return 0;
}

// This code is contributed by Shivam Gupta