Related Articles

Related Articles

Count of array elements that can be found using Randomized Binary Search on every array element
  • Difficulty Level : Hard
  • Last Updated : 18 Jan, 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[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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Funtion to find minimum count of
// array elements found by repeatedily
// 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 repeatedily
    // 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG
{
 
  // Funtion to find minimum count of
  // array elements found by repeatedily
  // 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 repeatedily
    // 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
import sys
 
# Funtion to find minimum count of
# array elements found by repeatedily
# 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 repeatedily
    # 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
 
class GFG
{
 
    // Funtion to find minimum count of
    // array elements found by repeatedily
    // 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 repeatedily
        // 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

chevron_right


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :