📌  相关文章
📜  可以在每个数组元素上使用随机二进制搜索找到的数组元素计数

📅  最后修改于: 2021-05-17 19:32:12             🧑  作者: Mango

给定大小为N的数组arr [] ,任务是查找通过对每个数组元素应用随机二进制搜索找到的数组元素的最小数量。

例子:

方法:想法是对所有数组元素都小于它的数组元素进行计数,然后计算所有元素都大于它的数组元素。请按照以下步骤解决问题:

  • 初始化一个数组,比如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 V


Python3
# 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


C#
// 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)