可以在每个数组元素上使用随机二分搜索找到的数组元素计数

给定一个大小为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

做法：思路是统计前面所有数组元素都小于它的数组元素，然后统计所有大于它的数组元素。请按照以下步骤解决问题：

• 初始化一个数组，比如minimumRight[]来存储每个数组元素右侧的最小元素。
• 反向遍历数组并更新minimumRight[i] = min(smallestRight[ i + 1], arr[i]) 。
• 遍历数组，将最大元素存储在每个数组元素的左侧，并检查左侧最大元素是否小于右侧最小元素。如果发现为真，则增加计数。
• 最后，打印获得的计数。

下面是上述方法的实现：

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& 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 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 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

// 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.

输出：

1

时间复杂度： O(N)
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。