第一句中最小字符的频率小于第二句中最小字符的频率

给定两个字符串数组，ARR1 []和ARR2 []中，任务是计数ARR2字符串的数量[]，其最小的字符的频率小于最小字符的用于ARR1每个字符串的频率[]。

例子：

Input: arr1[] = {“cbd”}, arr2[] = {“zaaaz”} 
Output: 1 
Explanation: 
The frequency of the smallest characters in “cbd” is 1 which is less than the frequency of the smallest characters in “zaaaz” which is 2. 
Therefore, the total count is 1 for the string “cbd”.

Input: arr1[] = {“yyy”,”zz”}, arr2[] = {“x”,”xx”,”xxx”,”xxxx”} 
Output: 1 2 
Explanation: 
1. The frequency of the smallest characters in “yyy” is 3 which is less than the frequency of the smallest characters in “xxxx” which is 4. 
Therefore, the total count is 1 for the string “yyy”. 
2. The frequency of the smallest characters in “zz” is 2 which is less than the frequency of the smallest characters in “xxx” and “xxxx” which is 3 and 4 respectively. 
Therefore, the total count is 2 for the string “zz”.  

方法：这个问题可以使用贪心方法来解决。以下是步骤：

1. 对于数组中的每个字符串， arr2[]计算最小字符的频率并将其存储在数组中(比如freq[] )。
2. 对频率数组freq[] 进行排序。
3. 现在，对于数组arr1[]中的每个字符串，计算字符串中最小字符的频率(比如X )。
4. 对于每个X ，使用本文讨论的方法使用二分搜索在freq[] 中找到大于 X 的元素数。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to count the frequency of
// minimum character
int countMinFreq(string s)
{
 
    // Sort the string s
    sort(s.begin(), s.end());
 
    // Return the count with smallest
    // character
    return count(s.begin(), s.end(), s[0]);
}
 
// Function to count number of frequency
// of smallest character of string arr1[]
// is less than the string in arr2[]
void countLessThan(vector& arr1,
                   vector& arr2)
{
    // To store the frequency of smallest
    // character in each string of arr2
    vector freq;
 
    // Traverse the arr2[]
    for (string s : arr2) {
 
        // Count the frequency of smallest
        // character in string s
        int f = countMinFreq(s);
 
        // Append the frequency to freq[]
        freq.push_back(f);
    }
 
    // Sort the frequency array
    sort(freq.begin(), freq.end());
 
    // Traverse the array arr1[]
    for (string s : arr1) {
 
        // Count the frequency of smallest
        // character in string s
        int f = countMinFreq(s);
 
        // find the element greater than f
        auto it = upper_bound(freq.begin(),
                              freq.end(), f);
 
        // Find the count such that
        // arr1[i] < arr2[j]
        int cnt = freq.size()
                  - (it - freq.begin());
 
        // Print the count
        cout << cnt << ' ';
    }
}
 
// Driver Code
int main()
{
 
    vector arr1, arr2;
    arr1 = { "yyy", "zz" };
    arr2 = { "x", "xx", "xxx", "xxxx" };
 
    // Function Call
    countLessThan(arr1, arr2);
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to count the frequency of
  // minimum character
  static int countMinFreq(String s)
  {
 
    // Sort the string s
    char[] tempArray = s.toCharArray();
    Arrays.sort(tempArray);
    s = new String(tempArray);
 
    // Return the count with smallest
    // character
    int x = 0;
    for (int i = 0; i < s.length(); i++)
      if (s.charAt(i) == s.charAt(0))
        x++;
    return x;
  }
 
  // Function to count number of frequency
  // of smallest character of string arr1[]
  // is less than the string in arr2[]
  static void countLessThan(List arr1,
                            List arr2)
  {
 
    // To store the frequency of smallest
    // character in each string of arr2
    List freq = new ArrayList();
 
    // Traverse the arr2[]
    for (String s : arr2)
    {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // Append the frequency to freq[]
      freq.add(f);
    }
 
    // Sort the frequency array
    Collections.sort(freq);
 
    // Traverse the array arr1[]
    for (String s : arr1) {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // find the element greater than f
      int it = upper_bound(freq, f);
 
      // Find the count such that
      // arr1[i] < arr2[j]
      int cnt = freq.size() - it;
 
      // Print the count
      System.out.print(cnt + " ");
    }
  }
 
  static int upper_bound(List freq, int f)
  {
    int low = 0, high = freq.size() - 1;
 
    while (low < high) {
      int mid = (low + high) / 2;
      if (freq.get(mid) > f)
        high = mid;
      else
        low = mid + 1;
    }
 
    return (freq.get(low) < f) ? low++ : low;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    List arr1, arr2;
    arr1 = Arrays.asList(new String[] { "yyy", "zz" });
    arr2 = Arrays.asList(
      new String[] { "x", "xx", "xxx", "xxxx" });
 
    // Function Call
    countLessThan(arr1, arr2);
  }
}
 
// This code is contributed by jithin.

Python3

# Python3 program for the above approach
from bisect import bisect_right as upper_bound
 
# Function to count the frequency
# of minimum character
def countMinFreq(s):
 
    # Sort the string s
    s = sorted(s)
 
    # Return the count with smallest
    # character
    x = 0
    for i in s:
        if i == s[0]:
            x += 1
    return x
 
# Function to count number of frequency
# of smallest character of string arr1[]
# is less than the string in arr2[]
def countLessThan(arr1, arr2):
     
    # To store the frequency of smallest
    # character in each string of arr2
    freq = []
 
    # Traverse the arr2[]
    for s in arr2:
 
        # Count the frequency of smallest
        # character in string s
        f = countMinFreq(s)
 
        # Append the frequency to freq[]
        freq.append(f)
 
    # Sort the frequency array
    feq = sorted(freq)
 
    # Traverse the array arr1[]
    for s in arr1:
 
        # Count the frequency of smallest
        # character in string s
        f = countMinFreq(s);
 
        # find the element greater than f
        it = upper_bound(freq,f)
 
        # Find the count such that
        # arr1[i] < arr2[j]
        cnt = len(freq)-it
 
        # Print the count
        print(cnt, end = " ")
 
# Driver Code
if __name__ == '__main__':
 
    arr1 = ["yyy", "zz"]
    arr2 = [ "x", "xx", "xxx", "xxxx"]
 
    # Function Call
    countLessThan(arr1, arr2);
 
# This code is contributed by Mohit Kumar

Javascript

 
// JS program for the above approach
function upper_bound(freq, f)
{
    let low = 0, high = freq.length - 1;
 
    while (low < high) {
        let mid = Math.floor((low + high) / 2);
        if (freq[mid] > f)
            high = mid;
          else
            low = mid + 1;
    }
 
    return (freq[low] < f) ? low++ : low;
}
// Function to count the frequency of
// minimum character
function countMinFreq(s)
{
 
    // Sort the string s
    s = s.split('').sort().join('');
    // Return the count with smallest
    // character
    let x = 0;
    for(let i=0;i<s.length;i++){
        if(s[i] == s[0])
            x += 1;
    }
    return x;
}
 
// Function to count number of frequency
// of smallest character of string arr1[]
// is less than the string in arr2[]
function countLessThan(arr1,arr2)
{
    // To store the frequency of smallest
    // character in each string of arr2
    let freq = [];
 
    // Traverse the arr2[]
    for (let i = 0;i< arr2.length;i++) {
 
        // Count the frequency of smallest
        // character in string s
        let f = countMinFreq(arr2[i]);
 
        // Append the frequency to freq[]
        freq.push(f);
    }
 
    // Sort the frequency array
    freq= freq.sort(function(a,b){return a-b});
    // Traverse the array arr1[]
    for (let i = 0;i< arr1.length;i++) {
 
        // Count the frequency of smallest
        // character in string s
        let f = countMinFreq(arr1[i]);
 
        // find the element greater than f
        let it = upper_bound(freq, f);
 
        // Find the count such that
        // arr1[i] < arr2[j]
        let cnt = freq.length
                  - (it);
 
        // Print the count
        document.write(cnt,' ');
    }
}
 
// Driver Code
let arr1, arr2;
arr1 = [ "yyy", "zz" ];
arr2 = [ "x", "xx", "xxx", "xxxx" ];
 
// Function Call
countLessThan(arr1, arr2);
 

输出：

1 2

时间复杂度： O(N + M*log M) ，其中 N 和 M 分别是给定数组的长度。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live