Number of indices pair such that element pair sum from first Array is greater than second Array - GeeksforGeeks

24 Dec, 2021
Given two integer arrays A[] and B[] of equal sizes, the task is to find the number of pairs of indices {i, j} in the arrays such that A[i] + A[j] > B[i] + B[j] and i < j.Examples:  
Input: A[] = {4, 8, 2, 6, 2}, B[] = {4, 5, 4, 1, 3} Output: 7 Explanation: There are a total of 7 pairs of indices {i, j} in the array following the condition. They are: {0, 1}: A[0] + A[1] > B[0] + B[1] {0, 3}: A[0] + A[3] > B[0] + B[3] {1, 2}: A[1] + A[2] > B[1] + B[2] {1, 3}: A[1] + A[3] > B[1] + B[3] {1, 4}: A[1] + A[4] > B[1] + B[4] {2, 3}: A[2] + A[3] > B[2] + B[3] {3, 4}: A[3] + A[4] > B[3] + B[4]Input: A[] = {1, 3, 2, 4}, B[] = {1, 3, 2, 4} Output: 0 Explanation: No such possible pairs of {i, j} can be found that satisfies the given condition  
Naive Approach: The naive approach is to consider all the possible pairs of {i, j} in the given arrays and check if A[i] + A[j] > B[i] + B[j]. This can be done by using the concept of nested loops.Time Complexity: O(N2)Efficient Approach: The key observation from the problem is that the given condition can also be visualised as (ai-bi) + (aj-bj)> 0 so we can make another array to store the difference of both arrays. let this array be D . Therefore, the problem reduces to finding pairs with Di+Dj>0. Now we can sort D array and for each corresponding element Di we will find the no of good pairs that Di can make and add this no of pairs to a count variable.For each element Di to find the no of good pairs it can make we can use the upper_bound function of the standard template library to find the upper bound of -Di. since the array is sorted so all elements present after -Di will also make good pair with Di .thus,if upper bound of -Di is x and n be the total size of array then total pairs corresponding to Di will be n-x. This approach takes O(NlogN) time. 
The given condition in the question can be rewritten as:  
A[i] + A[j] > B[i] + B[j]
A[i] + A[j] - B[i] - B[j] > 0
(A[i] - B[i]) + (A[j] - B[j]) > 0
Create another array, say D, to store the difference between elements at the corresponding index in both array, i.e.  
D[i] = A[i] - B[i]
Now to make sure that the constraint i < j is satisfied, sort the difference array D, so that each element i is smaller than elements to its right.
If at some index i, the value in the difference array D is negative, then we only need to find the nearest position ‘j’ at which the value is just greater than -D[i], so that on summation the value becomes > 0.Inorder to find such index ‘j’, upper_bound() function or Binary Search can be used, since the array is sorted.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to find the number of indices pair// such that pair sum from first Array// is greater than second Array #include <bits/stdc++.h>using namespace std; // Function to get the number of pairs of indices// {i, j} in the given two arrays A and B such that// A[i] + A[j] > B[i] + B[j]int getPairs(vector<int> A, vector<int> B, int n){    // Initializing the difference array D    vector<int> D(n);     // Computing the difference between the    // elements at every index and storing    // it in the array D    for (int i = 0; i < n; i++) {        D[i] = A[i] - B[i];    }     // Sort the array D    sort(D.begin(), D.end());     // Variable to store the total    // number of pairs that satisfy    // the given condition    long long total = 0;     // Loop to iterate through the difference    // array D and find the total number    // of pairs of indices that follow the    // given condition    for (int i = n - 1; i >= 0; i--) {         // If the value at the index i is positive,        // then it remains positive for any pairs        // with j such that j > i.        if (D[i] > 0) {            total += n - i - 1;        }         // If the value at that index is negative        // then we need to find the index of the        // value just greater than -D[i]        else {            int k = upper_bound(D.begin(),                                D.end(), -D[i])                    - D.begin();            total += n - k;        }    }    return total;} // Driver codeint main(){    int n = 5;    vector<int> A;    vector<int> B;     A.push_back(4);    A.push_back(8);    A.push_back(2);    A.push_back(6);    A.push_back(2);     B.push_back(4);    B.push_back(5);    B.push_back(4);    B.push_back(1);    B.push_back(3);     cout << getPairs(A, B, n);}
// Java program to find the number of indices pair// such that pair sum from first Array// is greater than second Arrayimport java.util.*; class GFG{ // Function to get the number of pairs of indices// {i, j} in the given two arrays A and B such that// A[i] + A[j] > B[i] + B[j]static long getPairs(Vector<Integer> A, Vector<Integer> B, int n){    // Initializing the difference array D    int []D = new int[n];     // Computing the difference between the    // elements at every index and storing    // it in the array D    for (int i = 0; i < n; i++)    {        D[i] = A.get(i) - B.get(i);    }     // Sort the array D    Arrays.sort(D);     // Variable to store the total    // number of pairs that satisfy    // the given condition    long total = 0;     // Loop to iterate through the difference    // array D and find the total number    // of pairs of indices that follow the    // given condition    for (int i = n - 1; i >= 0; i--) {         // If the value at the index i is positive,        // then it remains positive for any pairs        // with j such that j > i.        if (D[i] > 0) {            total += n - i - 1;        }         // If the value at that index is negative        // then we need to find the index of the        // value just greater than -D[i]        else {            int k = upper_bound(D,0, D.length, -D[i]);            total += n - k;        }    }    return total;}static int upper_bound(int[] a, int low,                        int high, int element){    while(low < high){        int middle = low + (high - low)/2;        if(a[middle] > element)            high = middle;        else            low = middle + 1;    }    return low;} // Driver codepublic static void main(String[] args){    int n = 5;    Vector<Integer> A = new Vector<Integer>();    Vector<Integer> B= new Vector<Integer>();     A.add(4);    A.add(8);    A.add(2);    A.add(6);    A.add(2);     B.add(4);    B.add(5);    B.add(4);    B.add(1);    B.add(3);     System.out.print(getPairs(A, B, n));}} // This code is contributed by 29AjayKumar
# Python 3 program to find the number of indices pair# such that pair sum from first Array# is greater than second Arrayimport bisect # Function to get the number of pairs of indices# {i, j} in the given two arrays A and B such that# A[i] + A[j] > B[i] + B[j]def getPairs(A,  B, n):     # Initializing the difference array D    D = [0]*(n)      # Computing the difference between the    # elements at every index and storing    # it in the array D    for i in range(n):        D[i] = A[i] - B[i]      # Sort the array D    D.sort()      # Variable to store the total    # number of pairs that satisfy    # the given condition    total = 0      # Loop to iterate through the difference    # array D and find the total number    # of pairs of indices that follow the    # given condition    for i in range(n - 1, -1, -1):          # If the value at the index i is positive,        # then it remains positive for any pairs        # with j such that j > i.        if (D[i] > 0):            total += n - i - 1          # If the value at that index is negative        # then we need to find the index of the        # value just greater than -D[i]        else:            k = bisect.bisect_right(D, -D[i], 0, len(D))            total += n - k    return total  # Driver codeif __name__ == "__main__":         n = 5    A = []    B = []      A.append(4);    A.append(8);    A.append(2);    A.append(6);    A.append(2);      B.append(4);    B.append(5);    B.append(4);    B.append(1);    B.append(3);      print(getPairs(A, B, n)) # This code is contributed by chitranayal
// C# program to find the number of indices pair// such that pair sum from first Array// is greater than second Arrayusing System;using System.Collections.Generic; class GFG{  // Function to get the number of pairs of indices// {i, j} in the given two arrays A and B such that// A[i] + A[j] > B[i] + B[j]static long getPairs(List<int> A, List<int> B, int n){    // Initializing the difference array D    int []D = new int[n];      // Computing the difference between the    // elements at every index and storing    // it in the array D    for (int i = 0; i < n; i++)    {        D[i] = A[i] - B[i];    }      // Sort the array D    Array.Sort(D);      // Variable to store the total    // number of pairs that satisfy    // the given condition    long total = 0;      // Loop to iterate through the difference    // array D and find the total number    // of pairs of indices that follow the    // given condition    for (int i = n - 1; i >= 0; i--) {          // If the value at the index i is positive,        // then it remains positive for any pairs        // with j such that j > i.        if (D[i] > 0) {            total += n - i - 1;        }          // If the value at that index is negative        // then we need to find the index of the        // value just greater than -D[i]        else {            int k = upper_bound(D,0, D.Length, -D[i]);            total += n - k;        }    }    return total;}static int upper_bound(int[] a, int low,                        int high, int element){    while(low < high){        int middle = low + (high - low)/2;        if(a[middle] > element)            high = middle;        else            low = middle + 1;    }    return low;}  // Driver codepublic static void Main(String[] args){    int n = 5;    List<int> A = new List<int>();    List<int> B= new List<int>();      A.Add(4);    A.Add(8);    A.Add(2);    A.Add(6);    A.Add(2);      B.Add(4);    B.Add(5);    B.Add(4);    B.Add(1);    B.Add(3);      Console.Write(getPairs(A, B, n));}} // This code is contributed by sapnasingh4991
<script>// Javascript program to find the number of indices pair// such that pair sum from first Array// is greater than second Array  // Function to get the number of pairs of indices// {i, j} in the given two arrays A and B such that// A[i] + A[j] > B[i] + B[j]function getPairs(A, B, n){    // Initializing the difference array D    let D = new Array(n);     // Computing the difference between the    // elements at every index and storing    // it in the array D    for (let i = 0; i < n; i++) {        D[i] = A[i] - B[i];    }     // Sort the array D    D.sort((a, b) => a - b);     // Variable to store the total    // number of pairs that satisfy    // the given condition    let total = 0;     // Loop to iterate through the difference    // array D and find the total number    // of pairs of indices that follow the    // given condition    for (let i = n - 1; i >= 0; i--) {         // If the value at the index i is positive,        // then it remains positive for any pairs        // with j such that j > i.        if (D[i] > 0) {            total += n - i - 1;        }         // If the value at that index is negative        // then we need to find the index of the        // value just greater than -D[i]        else {            let k = upper_bound(D, 0, D.length, -D[i])            total += n - k;        }    }    return total;} function upper_bound(a, low, high, element){    while(low < high){        let middle = low +  Math.floor((high - low)/2);        if(a[middle] > element)            high = middle;        else            low = middle + 1;    }    return low;} // Driver code     let n = 5;    let A = new Array();    let B = new Array();     A.push(4);    A.push(8);    A.push(2);    A.push(6);    A.push(2);     B.push(4);    B.push(5);    B.push(4);    B.push(1);    B.push(3);     document.write(getPairs(A, B, n))  // This code is contributed by gfgking</script>
7
 
Time Complexity Analysis: 
The sorting of the array takes O(N * log(N)) time.
The time taken to find the index which is just greater than a specific value is O(Log(N)). Since in the worst case, this can be executed for N elements in the array, the overall time complexity for this is O(N * log(N)).
Therefore, the overall time complexity is O(N * log(N)).
29AjayKumar
sapnasingh4991
ukasp
gfgking
simranarora5sos
Arrays
Greedy
Arrays
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
Dijkstra's shortest path algorithm | Greedy Algo-7
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Write a program to print all permutations of a given string
Huffman Coding | Greedy Algo-3