Skip to content
Related Articles

Related Articles

Improve Article

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

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

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[0] in the array. 
Initially, search space is [0, 2] 
Suppose pivot = 1 and arr[pivot] < arr[0]. Therefore, the new search space is [2, 2] and arr[0] not found in the search space. 
For arr[1], search space is [0, 2]. 
Suppose pivot = 0 and arr[pivot] > arr[0]. Therefore, the new search space is [0, 0] and arr[1] not found in the search space. 
For arr[2], search space is [0, 2]. 
Selecting any element as pivot, arr[2] 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 <bits/stdc++.h>
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[0]
    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[0]
    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[0]
    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[0]
        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




<script>
// javascript program of the above approach
 
  // Function to find minimum count of
  // array elements found by repeatedly
  // applying Randomized Binary Search
  function getDefiniteFinds(arr)
  {
  
    // Stores count of array elements
    let n = arr.length;
  
    // smallestRight[i]: Stores the smallest
    // array element on the right side of i
    let smallestRight = new Array(n+1).fill(0);
  
    // Update smallestRight[0]
    smallestRight[n] = Number.MAX_VALUE;
  
    // Traverse the array from right to left
    for (let 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
    let mn = Number.MIN_VALUE;
  
    // Stores the minimum count of
    // elements found by repeatedly
    // applying Randomized Binary Search
    let ans = 0;
    for (let 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
     
   // Given array
    let arr = [ 5, 4, 9 ];
  
    // Function Call
    document.write(getDefiniteFinds(arr));
  
 // This code is contributed by chinmoy1997pal.
</script>
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
Recommended Articles
Page :