Count of array elements that can be found using Randomized Binary Search on every array element
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: 2
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 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 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# 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
<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>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Count of elements that are binary searchable in the given array Given an array arr[] consisting of N integers, the task is to find the maximum count of integers that are binary searchable in the given array. Examples: Input: arr[] = {1, 3, 2}Output: 2Explanation: arr[0], arr[1] can be found. Input: arr[] = {3, 2, 1, 10, 23, 22, 21}Output: 3Explanation: arr[1], a
13 min read
Count remaining array elements after reversing binary representation of each array element Given an array arr[] consisting of N positive integers, the task is to modify every array element by reversing them binary representation and count the number of elements in the modified array that were also present in the original array. Examples: Input: arr[] = {2, 4, 5, 20, 16} Output: 2Explanati
8 min read
Count subarrays having a single distinct element that can be obtained from a given array Given an array arr[] of size N, the task is to count the number of subarrays consisting of a single distinct element that can be obtained from a given array. Examples: Input: N = 4, arr[] = { 2, 2, 2, 2 }Output: 7Explanation: All such subarrays {{2}, {2}, {2}, {2}, {2, 2}, {2, 2, 2}, {2, 2, 2, 2}}.
5 min read
Queries to count array elements from a given range having a single set bit Given an array arr[] consisting of N integers and a 2D array Q[][] consisting of queries of the following two types: 1 L R: Print the count of numbers from the range [L, R] having only a single set bit.2 X V: Update the array element at Xth index with V.Examples: Input: arr[] = { 12, 11, 16, 2, 32 }
15+ min read
Queries to count array elements from a given range having a single set bit Given an array arr[] consisting of positive integers and an array Q[][] consisting of queries, the task for every ith query is to count array elements from the range [Q[i][0], Q[i][1]] with only one set bit. Examples: Input: arr[] = {12, 11, 16, 8, 2, 5, 1, 3, 256, 1}, queries[][] = {{0, 9}, {4, 9}}
7 min read