使得第一数组的元素和更大的不同索引对(i，j)的计数

给定两个数组a []和b [] ，它们的大小均为N。任务是计算不同对的数量，以使(a [i] + a [j])>(b [i] + b [j])满足(j> i)的条件。

例子：

Input: N = 5, a[] = {1, 2, 3, 4, 5}, b[] = {2, 5, 6, 1, 9} 
Output: 1 
Explanation: 
Only one such pair exists and that is (0, 3). 
a[0] = 1, a[3] = 4 and a[0] + a[3] = 1 + 4 = 5. 
b[0] = 2, b[3] = 1 and b[0] + b[3] = 2 + 1 = 3. 
Clearly, 5 > 3 and j > i. Thus (0, 3) is a possible pair.

Input: N = 5, a[] = {2, 4, 2, 7, 8}, b[] = {1, 3, 6, 4, 5} 
Output: 6 

天真的方法：
最简单的方法是遍历每个可能的对，如果满足条件，则增加计数。然后，返回计数作为答案。

下面是上述方法的实现：

C++

// C++ program for the above problem
#include 
using namespace std;
 
// function to find the number of
// pairs satisfying the given cond.
int count_pairs(int a[],
                int b[], int N)
{
 
    // variables used for traversal
    int i, j;
 
    // count variable to store the
    // count of possible pairs
    int count = 0;
 
    // Nested loop to find out the
    // possible pairs
    for (i = 0; i < (N - 1); i++) {
        for (j = (i + 1); j < N; j++) {
 
            // Check if the given
            // condition is satisfied
            // or not. If yes then
            // increment the count.
            if ((a[i] + a[j])
                > (b[i] + b[j])) {
 
                count++;
            }
        }
    }
 
    // Return the count value
    return count;
}
 
// Driver Code
int main()
{
 
    // Size of the arrays
    int N = 5;
 
    // Initialise the arrays
    int a[N] = { 1, 2, 3, 4, 5 };
    int b[N] = { 2, 5, 6, 1, 9 };
 
    // function call that returns
    // the count of possible pairs
    cout << count_pairs(a, b, N)
         << endl;
 
    return 0;
}

Java

// Java program for the above problem
class GFG{
 
// function to find the number of
// pairs satisfying the given cond.
static int count_pairs(int []a,
                       int b[], int N)
{
 
    // variables used for traversal
    int i, j;
 
    // count variable to store the
    // count of possible pairs
    int count = 0;
 
    // Nested loop to find out the
    // possible pairs
    for (i = 0; i < (N - 1); i++)
    {
        for (j = (i + 1); j < N; j++)
        {
 
            // Check if the given
            // condition is satisfied
            // or not. If yes then
            // increment the count.
            if ((a[i] + a[j]) > (b[i] + b[j]))
            {
                count++;
            }
        }
    }
 
    // Return the count value
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
 
    // Size of the arrays
    int N = 5;
 
    // Initialise the arrays
    int a[] = new int[]{ 1, 2, 3, 4, 5 };
     
    int b[] = new int[]{ 2, 5, 6, 1, 9 };
 
    // function call that returns
    // the count of possible pairs
    System.out.println(count_pairs(a, b, N));
}
}
 
// This code is contributed by rock_cool

Python3

# Python3 program for the above problem
 
# function to find the number of
# pairs satisfying the given cond.
def count_pairs(a, b, N):
   
    # count variable to store the
    # count of possible pairs
    count = 0;
 
    # Nested loop to find out the
    # possible pairs
    for i in range(0, N - 1):
        for j in range(i + 1, N):
 
            # Check if the given
            # condition is satisfied
            # or not. If yes then
            # increment the count.
            if ((a[i] + a[j]) > (b[i] + b[j])):
                count += 1;
             
    # Return the count value
    return count;
 
# Driver Code
 
# Size of the arrays
N = 5;
 
# Initialise the arrays
a = [ 1, 2, 3, 4, 5 ];
b = [ 2, 5, 6, 1, 9 ];
 
# function call that returns
# the count of possible pairs
print(count_pairs(a, b, N)
 
# This code is contributed by Code_Mech

C#

// C# program for the above problem
using System;
class GFG{
 
// function to find the number of
// pairs satisfying the given cond.
static int count_pairs(int []a,
                       int []b, int N)
{
 
    // variables used for traversal
    int i, j;
 
    // count variable to store the
    // count of possible pairs
    int count = 0;
 
    // Nested loop to find out the
    // possible pairs
    for (i = 0; i < (N - 1); i++)
    {
        for (j = (i + 1); j < N; j++)
        {
 
            // Check if the given
            // condition is satisfied
            // or not. If yes then
            // increment the count.
            if ((a[i] + a[j]) > (b[i] + b[j]))
            {
                count++;
            }
        }
    }
 
    // Return the count value
    return count;
}
 
// Driver Code
public static void Main()
{
 
    // Size of the arrays
    int N = 5;
 
    // Initialise the arrays
    int []a = new int[]{ 1, 2, 3, 4, 5 };
     
    int []b = new int[]{ 2, 5, 6, 1, 9 };
 
    // function call that returns
    // the count of possible pairs
    Console.Write(count_pairs(a, b, N));
}
}
 
// This code is contributed by Code_Mech

Javascript

 
// Javascript program for the above problem
 
// function to find the number of
// pairs satisfying the given cond.
function count_pairs(a, b, N)
{
     
    // Variables used for traversal
    let i, j;
 
    // count variable to store the
    // count of possible pairs
    let count = 0;
 
    // Nested loop to find out the
    // possible pairs
    for(i = 0; i < (N - 1); i++)
    {
        for(j = (i + 1); j < N; j++)
        {
             
            // Check if the given
            // condition is satisfied
            // or not. If yes then
            // increment the count.
            if ((a[i] + a[j]) >
                (b[i] + b[j]))
            {
                count++;
            }
        }
    }
 
    // Return the count value
    return count;
}
     
// Driver code
 
// Size of the arrays
let N = 5;
 
// Initialise the arrays
let a = [ 1, 2, 3, 4, 5 ];
let b = [ 2, 5, 6, 1, 9 ];
 
// Function call that returns
// the count of possible pairs
document.write(count_pairs(a, b, N));
 
// This code is contributed by divyesh072019
 

输出：

1

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

高效方法：
请按照以下步骤解决问题：

• 将给定的不等式重新排列为：

=> a[i] + a[j] > b[i] + b[j] 
=> a[i] – b[i] + a[j] – b[j] > 0 

• 初始化另一个大小为N的数组c [] ，该数组存储a [i]-b [i]的值。
• 对数组c []排序。
• 将答案变量初始化为0。遍历数组c [] 。
• 对于数组c []中的每个索引i ，请执行以下操作：
  1. 如果c [i] <= 0 ，则继续。
  2. 如果c [i]> 0 ，则计算最小索引位置，并将该值存储在变量pos中，以使c [pos] + c [i]> 0 。使用C++ STL中的lower_bound函数可以轻松找到pos的值。
  3. 在答案中加上(i – pos) 。

Illustration: 

• N = 5, a[] = {1, 2, 3, 4, 5}, b[] = {2, 5, 6, 1, 9}
• The array c[] for this example will be c[] = {-1, -3, -3, 3, -4}
• After sorting, array c[] = {-4, -3, -3, -1, 3}
• The first and only positive value of array c[] is found at index 4.
• pos = lower_bound(-c[4] + 1) = lower_bound(-2) = 3.
• Count of possible pairs = i – pos = 4 – 3 = 1.

Note: Had there been more than one positive number found in the array c[], then find out the pos for each and every postive value in c[] and add the value of i – pos to the count. 

下面是上述方法的实现：

C++

// C++ program of the above approach
#include 
using namespace std;
 
// Function to find the number
// of pairs.
int numberOfPairs(int* a,
                  int* b, int n)
{
 
    // Array c[] where
    // c[i] = a[i] - b[i]
    int c[n];
 
    for (int i = 0; i < n; i++) {
        c[i] = a[i] - b[i];
    }
 
    // Sort the array c
    sort(c, c + n);
 
    // Initialise answer as 0
    int answer = 0;
 
    // Iterate from index
    // 0 to n - 1
    for (int i = 1; i < n; i++) {
 
        // If c[i] <= 0 then
        // in the sorted array
        // c[i] + c[pos] can never
        // greater than 0
        // where pos < i
        if (c[i] <= 0)
            continue;
 
        // Find the minimum index
        // such that c[i] + c[j] > 0
        // which is equivalent to
        // c[j] >= - c[i] + 1
        int pos = lower_bound(c, c + n,
                              -c[i] + 1)
                  - c;
 
        // Add ( i - pos) to answer
        answer += (i - pos);
    }
 
    // return the answer
    return answer;
}
 
// Driver code
int32_t main()
{
    // Number of elements
    // in a and b
    int n = 5;
 
    // array a
    int a[] = { 1, 2, 3, 4, 5 };
 
    // array b
    int b[] = { 2, 5, 6, 1, 9 };
 
    cout << numberOfPairs(a, b, n)
         << endl;
 
    return 0;
}

Java

// Java program of the above approach
import java.util.*;
 
class GFG{
     
// Function to find the number
// of pairs.
static int numberOfPairs(int[] a,
                         int[] b, int n)
{
     
    // Array c[] where
    // c[i] = a[i] - b[i]
    int c[] = new int[n];
  
    for(int i = 0; i < n; i++)
    {
        c[i] = a[i] - b[i];
    }
  
    // Sort the array c
    Arrays.sort(c);
  
    // Initialise answer as 0
    int answer = 0;
  
    // Iterate from index
    // 0 to n - 1
    for(int i = 1; i < n; i++)
    {
         
        // If c[i] <= 0 then
        // in the sorted array
        // c[i] + c[pos] can never
        // greater than 0
        // where pos < i
        if (c[i] <= 0)
            continue;
             
        // Which is equivalent to
        // c[j] >= - c[i] + 1
        int pos = -1;
        for(int j = 0; j < n; j++)
        {
            if (c[i] + c[j] > 0)
            {
                pos = j;
                break;
            }
        }
         
        // Add (i - pos) to answer
        answer += (i - pos);
    }
     
    // Return the answer
    return answer;
}
  
// Driver code   
public static void main (String[] args)
{
     
    // Number of elements
    // in a and b
    int n = 5;
     
    // array a
    int a[] = { 1, 2, 3, 4, 5 };
     
    // array b
    int b[] = { 2, 5, 6, 1, 9 };
     
    System.out.println(numberOfPairs(a, b, n));
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program of the above approach
from bisect import bisect_left
 
# Function to find the number
# of pairs.
def numberOfPairs(a, b, n):
     
    # Array c[] where
    # c[i] = a[i] - b[i]
    c = [0 for i in range(n)]
 
    for i in range(n):
        c[i] = a[i] - b[i]
 
    # Sort the array c
    c = sorted(c)
 
    # Initialise answer as 0
    answer = 0
 
    # Iterate from index
    # 0 to n - 1
    for i in range(1, n):
 
        # If c[i] <= 0 then in the
        # sorted array c[i] + c[pos]
        # can never greater than 0
        # where pos < i
        if (c[i] <= 0):
            continue
 
        # Find the minimum index
        # such that c[i] + c[j] > 0
        # which is equivalent to
        # c[j] >= - c[i] + 1
        pos = bisect_left(c, -c[i] + 1)
 
        # Add ( i - pos) to answer
        answer += (i - pos)
 
    # Return the answer
    return answer
 
# Driver code
if __name__ == '__main__':
     
    # Number of elements
    # in a and b
    n = 5
 
    # Array a
    a = [ 1, 2, 3, 4, 5 ]
  
    # Array b
    b = [ 2, 5, 6, 1, 9 ]
 
    print(numberOfPairs(a, b, n))
 
# This code is contributed by mohit kumar 29

C＃

// C# program of the above approach
using System;
 
class GFG{
     
// Function to find the number
// of pairs.
static int numberOfPairs(int[] a,
                         int[] b, int n)
{
     
    // Array c[] where
    // c[i] = a[i] - b[i]
    int[] c = new int[n];
   
    for(int i = 0; i < n; i++)
    {
        c[i] = a[i] - b[i];
    }
   
    // Sort the array c
    Array.Sort(c);
   
    // Initialise answer as 0
    int answer = 0;
   
    // Iterate from index
    // 0 to n - 1
    for(int i = 1; i < n; i++)
    {
         
        // If c[i] <= 0 then
        // in the sorted array
        // c[i] + c[pos] can never
        // greater than 0
        // where pos < i
        if (c[i] <= 0)
            continue;
              
        // Which is equivalent to
        // c[j] >= - c[i] + 1
        int pos = -1;
        for(int j = 0; j < n; j++)
        {
            if (c[i] + c[j] > 0)
            {
                pos = j;
                break;
            }
        }
          
        // Add (i - pos) to answer
        answer += (i - pos);
    }
     
    // Return the answer
    return answer;
}
 
// Driver Code
static void Main()
{
     
    // Number of elements
    // in a and b
    int n = 5;
      
    // Array a
    int[] a = { 1, 2, 3, 4, 5 };
      
    // Array b
    int[] b = { 2, 5, 6, 1, 9 };
      
    Console.WriteLine(numberOfPairs(a, b, n));
}
}
 
// This code is contributed by divyeshrabadiya07

Java脚本

 
    // Javascript program of the above approach
     
    // Function to find the number of pairs.
    function numberOfPairs(a, b, n)
    {
 
        // Array c[] where
        // c[i] = a[i] - b[i]
        let c = new Array(n);
 
        for(let i = 0; i < n; i++)
        {
            c[i] = a[i] - b[i];
        }
 
        // Sort the array c
        c.sort(function(a, b){return a - b});
 
        // Initialise answer as 0
        let answer = 0;
 
        // Iterate from index
        // 0 to n - 1
        for(let i = 1; i < n; i++)
        {
 
            // If c[i] <= 0 then
            // in the sorted array
            // c[i] + c[pos] can never
            // greater than 0
            // where pos < i
            if (c[i] <= 0)
                continue;
 
            // Which is equivalent to
            // c[j] >= - c[i] + 1
            let pos = -1;
            for(let j = 0; j < n; j++)
            {
                if (c[i] + c[j] > 0)
                {
                    pos = j;
                    break;
                }
            }
 
            // Add (i - pos) to answer
            answer += (i - pos);
        }
 
        // Return the answer
        return answer;
    }
     
    // Number of elements
    // in a and b
    let n = 5;
       
    // Array a
    let a = [ 1, 2, 3, 4, 5 ];
       
    // Array b
    let b = [ 2, 5, 6, 1, 9 ];
       
    document.write(numberOfPairs(a, b, n));
     

输出：

1

时间复杂度： O(N * log(N))，其中N是数组中元素的数量。
辅助空间： O(N)