给定大小为N的数组arr [] ，任务是查找通过对每个数组元素应用随机二进制搜索找到的数组元素的最小数量。
例子：
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
方法：想法是对所有数组元素都小于它的数组元素进行计数，然后计算所有元素都大于它的数组元素。请按照以下步骤解决问题：
- 初始化一个数组，比如smallestRight [] ，将最小的元素存储在每个数组元素的右侧。
- 反向遍历数组，并更新minimumRight [i] = min(smallestRight [i + 1]，arr [i]) 。
- 遍历数组并将最大的元素存储在每个数组元素的左侧，然后检查左侧的最大元素是否小于右侧的最小元素。如果发现为真，则增加计数。
- 最后，打印获得的计数。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Funtion to find minimum count of
// array elements found by repeatedily
// applying Randomized Binary Search
int getDefiniteFinds(vector& arr)
{
// Stores count of array elements
int n = arr.size();
// smallestRight[i]: Stores the smallest
// array element on the right side of i
vector 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 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
{
// 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 VPython3
# 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 susmitakundugoaldangaC#
// 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输出：
1时间复杂度： O(N)
辅助空间： O(N)