在数组中查找 (x, y) 对的数量，使得 x^y > y^x | 2套

给定两个正整数数组X[]和Y[] ，找到满足x^y > y^x的对数，其中 x 是 X[] 中的一个元素，y 是 Y[] 中的一个元素。
例子：

Input: X[] = {2, 1, 6}, Y = {1, 5} 
Output: 3 
Explanation: 
The 3 possible pairs are: 
(2, 1) => 2¹ > 1² 
(2, 5) => 2⁵ (= 32) > 5² (= 25) 
(6, 1) => 6¹ > 1⁶
Input: X[] = {10, 19, 18}, Y[] = {11, 15, 9} 
Output: 2 
Explanation: 
The possible pairs are (10, 11) and (10, 15).

对于 Naive Approach [O(M*N)] 和 [O(N logN + M logN)] 方法，请参考本文的 Set 1 。
高效的方法：以上两种方法可以在O(N) 时间复杂度上进一步优化。
这种方法使用后缀和的概念来找到解决方案。我们可以观察到，如果 y > x，那么 x^y > y^x。但是，需要考虑以下基本情况和例外情况：

• 如果 x = 0，则可能的 y 计数为 0。
• 如果 x = 1，则可能 y 的计数是 0 的频率，即 Y[] 是所需的答案。
• 如果 x = 2, 2 ³ < 3 ²和 2 ⁴ = 4 ² 。因此，对于 x = 2，我们不能有 y = {2, 3, 4} 的有效对。因此，Y[] 中 0、1 和所有数字 gt 4 的频率之和为我们提供了所需有效对的数量
• 如果 x = 3，则 Y[] 中除 3 之外的所有频率的总和为我们提供所需的可能对数。

请按照以下步骤解决问题：

• 存储Y数组每个元素的频率。
• 存储包含频率的数组的后缀和。
• 对于 X[] 中不属于任何基本情况的每个元素 x，y 的可能数量将是后缀 [x+1] + Y[] 中 0 的计数 + Y[] 中 1 的计数。对于基本情况，如上所述相应地计算对。
• 打印对的总数。

下面是上述方法的实现：

C++

// C++ program to finds the number of
// pairs (x, y) from X[] and Y[]
// such that x^y > y^x
 
#include 
using namespace std;
 
// Function to return the count of pairs
int countPairs(int X[], int Y[], int m,
               int n)
{
    vector suffix(1005);
    long long total_pairs = 0;
    for (int i = 0; i < n; i++)
        suffix[Y[i]]++;
 
    // Compute suffix sums till i = 3
    for (int i = 1e3; i >= 3; i--)
        suffix[i] += suffix[i + 1];
 
    for (int i = 0; i < m; i++) {
 
        // Base Case: x = 0
        if (X[i] == 0)
 
            // No valid pairs
            continue;
 
        // Base Case: x = 1
        else if (X[i] == 1) {
 
            // Store the count of 0's
            total_pairs += suffix[0];
            continue;
        }
 
        // Base Case: x = 2
        else if (X[i] == 2)
 
            // Store suffix sum upto 5
            total_pairs += suffix[5];
 
        // Base Case: x = 3
        else if (X[i] == 3)
 
            // Store count of 2 and
            // suffix sum upto 4
            total_pairs += suffix[2]
                           + suffix[4];
 
        // For all other values of x
        else
            total_pairs += suffix[X[i] + 1];
 
        // For all x >=2, every y = 0
        // and every y = 1 makes a valid pair
        total_pairs += suffix[0] + suffix[1];
    }
 
    // Return the count of pairs
    return total_pairs;
}
 
// Driver Program
int main()
{
    int X[] = { 10, 19, 18 };
    int Y[] = { 11, 15, 9 };
 
    int m = sizeof(X) / sizeof(X[0]);
    int n = sizeof(Y) / sizeof(Y[0]);
 
    cout << countPairs(X, Y, m, n);
 
    return 0;
}

Java

// Java program to finds the number of
// pairs (x, y) from X[] and Y[]
// such that x^y > y^x
class GFG{
     
// Function to return the count of pairs
static int countPairs(int X[], int Y[], int m,
                      int n)
{
    int []suffix = new int[1005];
    long total_pairs = 0;
     
    for(int i = 0; i < n; i++)
        suffix[Y[i]]++;
     
    // Compute suffix sums till i = 3
    for(int i = (int)1e3; i >= 3; i--)
        suffix[i] += suffix[i + 1];
     
    for(int i = 0; i < m; i++)
    {
         
        // Base Case: x = 0
        if (X[i] == 0)
     
            // No valid pairs
            continue;
     
        // Base Case: x = 1
        else if (X[i] == 1)
        {
     
            // Store the count of 0's
            total_pairs += suffix[0];
            continue;
        }
     
        // Base Case: x = 2
        else if (X[i] == 2)
     
            // Store suffix sum upto 5
            total_pairs += suffix[5];
     
        // Base Case: x = 3
        else if (X[i] == 3)
     
            // Store count of 2 and
            // suffix sum upto 4
            total_pairs += suffix[2] +
                           suffix[4];
     
        // For all other values of x
        else
            total_pairs += suffix[X[i] + 1];
     
        // For all x >=2, every y = 0
        // and every y = 1 makes a valid pair
        total_pairs += suffix[0] + suffix[1];
    }
     
    // Return the count of pairs
    return (int) total_pairs;
}
     
// Driver code
public static void main(String[] args)
{
    int X[] = { 10, 19, 18 };
    int Y[] = { 11, 15, 9 };
     
    int m = X.length;
    int n = Y.length;
     
    System.out.print(countPairs(X, Y, m, n));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to finds the number of
# pairs (x, y) from X[] and Y[]
# such that x^y > y^x
 
# Function to return the count of pairs
def countPairs(X, Y, m, n):
 
    suffix = [0] * 1005
    total_pairs = 0
 
    for i in range(n):
        suffix[Y[i]] += 1
 
    # Compute suffix sums till i = 3
    for i in range(int(1e3), 2, -1 ):
        suffix[i] += suffix[i + 1]
 
    for i in range(m):
 
        # Base Case: x = 0
        if(X[i] == 0):
             
            # No valid pairs
            continue
 
        # Base Case: x = 1
        elif(X[i] == 1):
 
            # Store the count of 0's
            total_pairs += suffix[0]
            continue
 
        # Base Case: x = 2
        elif(X[i] == 2):
 
            # Store suffix sum upto 5
            total_pairs += suffix[5]
 
        # Base Case: x = 3
        elif(X[i] == 3):
 
            # Store count of 2 and
            # suffix sum upto 4
            total_pairs += (suffix[2] +
                            suffix[4])
 
        # For all other values of x
        else:
            total_pairs += suffix[X[i] + 1]
 
        # For all x >=2, every y = 0
        # and every y = 1 makes a valid pair
        total_pairs += suffix[0] + suffix[1]
 
    # Return the count of pairs
    return total_pairs
 
# Driver code
if __name__ == '__main__':
 
    X = [ 10, 19, 18 ]
    Y = [ 11, 15, 9 ]
 
    m = len(X)
    n = len(Y)
 
    print(countPairs(X, Y, m, n))
 
# This code is contributed by Shivam Singh

C#

// C# program to finds the number of
// pairs (x, y) from []X and []Y
// such that x^y > y^x
using System;
class GFG{
 
    // Function to return the count of pairs
    static int countPairs(int[] X, int[] Y, int m, int n)
    {
        int[] suffix = new int[1005];
        long total_pairs = 0;
        for (int i = 0; i < n; i++)
            suffix[Y[i]]++;
 
        // Compute suffix sums till i = 3
        for (int i = (int)1e3; i >= 3; i--)
            suffix[i] += suffix[i + 1];
 
        for (int i = 0; i < m; i++)
        {
 
            // Base Case: x = 0
            if (X[i] == 0)
 
                // No valid pairs
                continue;
 
            // Base Case: x = 1
            else if (X[i] == 1)
            {
 
                // Store the count of 0's
                total_pairs += suffix[0];
                continue;
            }
 
            // Base Case: x = 2
            else if (X[i] == 2)
 
                // Store suffix sum upto 5
                total_pairs += suffix[5];
 
            // Base Case: x = 3
            else if (X[i] == 3)
 
                // Store count of 2 and
                // suffix sum upto 4
                total_pairs += suffix[2] + suffix[4];
 
            // For all other values of x
            else
                total_pairs += suffix[X[i] + 1];
 
            // For all x >=2, every y = 0
            // and every y = 1 makes a valid pair
            total_pairs += suffix[0] + suffix[1];
        }
 
        // Return the count of pairs
        return (int)total_pairs;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int[] X = {10, 19, 18};
        int[] Y = {11, 15, 9};
        int m = X.Length;
        int n = Y.Length;
        Console.Write(countPairs(X, Y, m, n));
    }
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// JavaScript program to implement
// the above approach
 
// Function to return the count of pairs
function countPairs(X, Y, m, n)
{
    let suffix = Array.from({length: 1005}, (_, i) => 0);
    let total_pairs = 0;
      
    for(let i = 0; i < n; i++)
        suffix[Y[i]]++;
      
    // Compute suffix sums till i = 3
    for(let i = 1e3; i >= 3; i--)
        suffix[i] += suffix[i + 1];
      
    for(let i = 0; i < m; i++)
    {
          
        // Base Case: x = 0
        if (X[i] == 0)
      
            // No valid pairs
            continue;
      
        // Base Case: x = 1
        else if (X[i] == 1)
        {
      
            // Store the count of 0's
            total_pairs += suffix[0];
            continue;
        }
      
        // Base Case: x = 2
        else if (X[i] == 2)
      
            // Store suffix sum upto 5
            total_pairs += suffix[5];
      
        // Base Case: x = 3
        else if (X[i] == 3)
      
            // Store count of 2 and
            // suffix sum upto 4
            total_pairs += suffix[2] +
                           suffix[4];
      
        // For all other values of x
        else
            total_pairs += suffix[X[i] + 1];
      
        // For all x >=2, every y = 0
        // and every y = 1 makes a valid pair
        total_pairs += suffix[0] + suffix[1];
    }
      
    // Return the count of pairs
    return total_pairs;
}
 
// Driver code
 
     
    let X = [ 10, 19, 18 ];
    let Y = [ 11, 15, 9 ];
      
    let m = X.length;
    let n = Y.length;
      
    document.write(countPairs(X, Y, m, n));
 
// This code is contributed by susmitakundugoaldanga.

输出：

2

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

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