Related Articles

# Count of array elements that can be found using Randomized Binary Search on every array element

• Difficulty Level : Hard
• Last Updated : 29 May, 2021

Given an array arr[] of size N, the task is to find the minimum count of array elements found by applying the Randomized Binary Search for each array elements.

Examples:

Input: arr[] = { 5, 4, 9 }
Output:
Explanation:
Applying Randomized Binary Search for arr in the array.
Initially, search space is [0, 2]
Suppose pivot = 1 and arr[pivot] < arr. Therefore, the new search space is [2, 2] and arr not found in the search space.
For arr, search space is [0, 2].
Suppose pivot = 0 and arr[pivot] > arr. Therefore, the new search space is [0, 0] and arr not found in the search space.
For arr, search space is [0, 2].
Selecting any element as pivot, arr can be found.

Input: arr[] = { 1, 2, 3, 4 }
Output: 4

Approach: The idea is to count the array elements before which all array elements are smaller than it, and after which all are greater than it. Follow the steps below to solve the problem:

• Initialize an array, say smallestRight[] to store the smallest element on the right side of each array element.
• Traverse the array in reverse and update smallestRight[i] = min(smallestRight[ i + 1], arr[i]).
• Traverse the array and store the largest element on the left side of each array element and check if the largest element on the left side is less than the smallest element on the right side or not. If found to be true, then increment the count.
• Finally, print the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find minimum count of``// array elements found by repeatedly``// applying Randomized Binary Search``int` `getDefiniteFinds(vector<``int``>& arr)``{` `    ``// Stores count of array elements``    ``int` `n = arr.size();` `    ``// smallestRight[i]: Stores the smallest``    ``// array element on the right side of i``    ``vector<``int``> smallestRight(n + 1);` `    ``// Update smallestRight``    ``smallestRight[n] = INT_MAX;` `    ``// Traverse the array from right to left``    ``for` `(``int` `i = n - 1; i >= 0; i--) {` `        ``// Update smallestRight[i]``        ``smallestRight[i]``            ``= min(smallestRight[i + 1], arr[i]);``    ``}` `    ``// Stores the largest element``    ``// upto i-th index``    ``int` `mn = INT_MIN;` `    ``// Stores the minimum count of``    ``// elements found by repeatedly``    ``// applying Randomized Binary Search``    ``int` `ans = 0;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If largest element on left side is``        ``// less than smallest element on right side``        ``if` `(mn < arr[i] and arr[i] < smallestRight[i + 1]) {` `            ``// Update ans``            ``ans++;``        ``}` `        ``// Update mn``        ``mn = max(arr[i], mn);``    ``}` `    ``return` `ans;``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``vector<``int``> arr = { 5, 4, 9 };` `    ``// Function Call``    ``cout << getDefiniteFinds(arr) << endl;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// Function to find minimum count of``  ``// array elements found by repeatedly``  ``// applying Randomized Binary Search``  ``static` `int` `getDefiniteFinds(``int``[] arr)``  ``{` `    ``// Stores count of array elements``    ``int` `n = arr.length;` `    ``// smallestRight[i]: Stores the smallest``    ``// array element on the right side of i``    ``int``[] smallestRight = ``new` `int``[n + ``1``];` `    ``// Update smallestRight``    ``smallestRight[n] = Integer.MAX_VALUE;` `    ``// Traverse the array from right to left``    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)``    ``{` `      ``// Update smallestRight[i]``      ``smallestRight[i]``        ``= Math.min(smallestRight[i + ``1``], arr[i]);``    ``}` `    ``// Stores the largest element``    ``// upto i-th index``    ``int` `mn = Integer.MIN_VALUE;` `    ``// Stores the minimum count of``    ``// elements found by repeatedly``    ``// applying Randomized Binary Search``    ``int` `ans = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `      ``// If largest element on left side is``      ``// less than smallest element on right side``      ``if` `(mn < arr[i]``          ``&& arr[i] < smallestRight[i + ``1``])``      ``{` `        ``// Update ans``        ``ans++;``      ``}` `      ``// Update mn``      ``mn = Math.max(arr[i], mn);``    ``}``    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Given array``    ``int``[] arr = ``new` `int``[] { ``5``, ``4``, ``9` `};` `    ``// Function Call``    ``System.out.println(getDefiniteFinds(arr));``  ``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to find minimum count of``# array elements found by repeatedly``# applying Randomized Binary Search``def` `getDefiniteFinds(arr):``    ` `    ``# Stores count of array elements``    ``n ``=` `len``(arr)` `    ``# smallestRight[i]: Stores the smallest``    ``# array element on the right side of i``    ``smallestRight ``=` `[``0``] ``*` `(n ``+` `1``)` `    ``# Update smallestRight``    ``smallestRight[n] ``=` `sys.maxsize` `    ``# Traverse the array from right to left``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):` `        ``# Update smallestRight[i]``        ``smallestRight[i] ``=` `min``(``            ``smallestRight[i ``+` `1``], arr[i])``    ` `    ``# Stores the largest element``    ``# upto i-th index``    ``mn ``=` `-``sys.maxsize ``-` `1` `    ``# Stores the minimum count of``    ``# elements found by repeatedly``    ``# applying Randomized Binary Search``    ``ans ``=` `0``    ` `    ``for` `i ``in` `range``(n):``        ` `        ``# If largest element on left side is``        ``# less than smallest element on right side``        ``if` `(mn < arr[i] ``and``        ``arr[i] < smallestRight[i ``+` `1``]):` `            ``# Update ans``            ``ans ``+``=` `1``        ` `        ``# Update mn``        ``mn ``=` `max``(arr[i], mn)``    ` `    ``return` `ans` `# Driver Code` `# Given array``arr ``=` `[ ``5``, ``4``, ``9` `]` `# Function Call``print``(getDefiniteFinds(arr))` `# This code is contributed by susmitakundugoaldanga`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG``{` `    ``// Function to find minimum count of``    ``// array elements found by repeatedly``    ``// applying Randomized Binary Search``    ``static` `int` `getDefiniteFinds(``int``[] arr)``    ``{` `        ``// Stores count of array elements``        ``int` `n = arr.Length;` `        ``// smallestRight[i]: Stores the smallest``        ``// array element on the right side of i``        ``int``[] smallestRight = ``new` `int``[n + 1];` `        ``// Update smallestRight``        ``smallestRight[n] = Int32.MaxValue;` `        ``// Traverse the array from right to left``        ``for` `(``int` `i = n - 1; i >= 0; i--)``        ``{` `            ``// Update smallestRight[i]``            ``smallestRight[i]``                ``= Math.Min(smallestRight[i + 1], arr[i]);``        ``}` `        ``// Stores the largest element``        ``// upto i-th index``        ``int` `mn = Int32.MinValue;` `        ``// Stores the minimum count of``        ``// elements found by repeatedly``        ``// applying Randomized Binary Search``        ``int` `ans = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// If largest element on left side is``            ``// less than smallest element on right side``            ``if` `(mn < arr[i]``                ``&& arr[i] < smallestRight[i + 1])``            ``{` `                ``// Update ans``                ``ans++;``            ``}` `            ``// Update mn``            ``mn = Math.Max(arr[i], mn);``        ``}``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{` `        ``// Given array``        ``int``[] arr = ``new` `int``[] { 5, 4, 9 };` `        ``// Function Call``        ``Console.WriteLine(getDefiniteFinds(arr));``    ``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``
Output:
`1`

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up