# Count all disjoint pairs having absolute difference at least K from a given array

Given an array arr[] consisting of N integers, the task is to count all disjoint pairs having absolute difference at least K
Note: The pair (arr[i], arr[j]) and (arr[j], arr[i]) are considered as the same pair.

Examples:

Input: arr[] = {1, 3, 3, 5}, K = 2
Output: 2
Explanation:
The following two pairs satisfy the necessary conditions:

• {arr[0], arr[1]} = (1, 3) whose absolute difference is |1 – 3| = 2
• {arr[2], arr[3]} = (3, 5) whose absolute difference is |3 – 5| = 2

Input: arr[] = {1, 2, 3, 4}, K = 3
Output: 1
Explanation:
The only pair satisfying the necessary conditions is {arr[0], arr[3]} = (1, 4), since |1 – 4| = 3.

Naive Approach: The simplest approach is to generate all possible pairs of the given array and count those pairs whose absolute difference is at least K and to keep track of elements that have already been taken into pairs, using an auxiliary array visited[] to mark the paired elements.

Below is the implementation of the above approach:

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count distinct pairs` `// with absolute difference atleast K` `void` `countPairsWithDiffK(``int` `arr[],` `                         ``int` `N, ``int` `K)` `{` `    ``// Track the element that` `    ``// have been paired` `    ``int` `vis[N];` `    ``memset``(vis, 0, ``sizeof``(vis));`   `    ``// Stores count of distinct pairs` `    ``int` `count = 0;`   `    ``// Pick all elements one by one` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// If already visited` `        ``if` `(vis[i] == 1)` `            ``continue``;`   `        ``for` `(``int` `j = i + 1; j < N; j++) {`   `            ``// If already visited` `            ``if` `(vis[j] == 1)` `                ``continue``;`   `            ``// If difference is at least K` `            ``if` `(``abs``(arr[i] - arr[j]) >= K) {`   `                ``// Mark element as visited and` `                ``// increment the count` `                ``count++;` `                ``vis[i] = 1;` `                ``vis[j] = 1;` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// Print the final count` `    ``cout << count << ``' '``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given arr[]` `    ``int` `arr[] = { 1, 3, 3, 5 };`   `    ``// Size of array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Given difference K` `    ``int` `K = 2;`   `    ``// Function Call` `    ``countPairsWithDiffK(arr, N, K);`   `    ``return` `0;` `}`

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{` ` `  `// Function to count distinct pairs` `// with absolute difference atleast K` `static` `void` `countPairsWithDiffK(``int` `arr[],` `                                ``int` `N, ``int` `K)` `{` `    `  `    ``// Track the element that` `    ``// have been paired` `    ``int` `[]vis = ``new` `int``[N];` `    ``Arrays.fill(vis, ``0``);` `    `  `    ``// Stores count of distinct pairs` `    ``int` `count = ``0``;`   `    ``// Pick all elements one by one` `    ``for``(``int` `i = ``0``; i < N; i++) ` `    ``{` `        `  `        ``// If already visited` `        ``if` `(vis[i] == ``1``)` `            ``continue``;`   `        ``for``(``int` `j = i + ``1``; j < N; j++) ` `        ``{` `            `  `            ``// If already visited` `            ``if` `(vis[j] == ``1``)` `                ``continue``;`   `            ``// If difference is at least K` `            ``if` `(Math.abs(arr[i] - arr[j]) >= K) ` `            ``{` `                `  `                ``// Mark element as visited and` `                ``// increment the count` `                ``count++;` `                ``vis[i] = ``1``;` `                ``vis[j] = ``1``;` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// Print the final count` `    ``System.out.print(count);` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    `  `    ``// Given arr[]` `    ``int` `arr[] = { ``1``, ``3``, ``3``, ``5` `};`   `    ``// Size of array` `    ``int` `N = arr.length;`   `    ``// Given difference K` `    ``int` `K = ``2``;`   `    ``// Function Call` `    ``countPairsWithDiffK(arr, N, K);` `}` `}`   `// This code is contributed by bgangwar59`

 `# Python3 program for the above approach`   `# Function to count distinct pairs` `# with absolute difference atleast K` `def` `countPairsWithDiffK(arr, N, K):` `    `  `    ``# Track the element that` `    ``# have been paired` `    ``vis ``=` `[``0``] ``*` `N` `    `  `    ``# Stores count of distinct pairs` `    ``count ``=` `0`   `    ``# Pick all elements one by one` `    ``for` `i ``in` `range``(N):` `        `  `        ``# If already visited` `        ``if` `(vis[i] ``=``=` `1``):` `            ``continue`   `        ``for` `j ``in` `range``(i ``+` `1``, N):` `            `  `            ``# If already visited` `            ``if` `(vis[j] ``=``=` `1``):` `                ``continue`   `            ``# If difference is at least K` `            ``if` `(``abs``(arr[i] ``-` `arr[j]) >``=` `K):`   `                ``# Mark element as visited and` `                ``# increment the count` `                ``count ``+``=` `1` `                ``vis[i] ``=` `1` `                ``vis[j] ``=` `1` `                ``break`   `    ``# Print the final count` `    ``print``(count)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given arr[]` `    ``arr ``=` `[ ``1``, ``3``, ``3``, ``5` `]`   `    ``# Size of array` `    ``N ``=` `len``(arr)` `    `  `    ``# Given difference K` `    ``K ``=` `2`   `    ``# Function Call` `    ``countPairsWithDiffK(arr, N, K)`   `# This code is contributed by mohit kumar 29`

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to count distinct pairs` `// with absolute difference atleast K` `static` `void` `countPairsWithDiffK(``int``[] arr, ``int` `N,` `                                ``int` `K)` `{` `    `  `    ``// Track the element that` `    ``// have been paired` `    ``int``[] vis = ``new` `int``[N];`   `    ``// Stores count of distinct pairs` `    ``int` `count = 0;`   `    ``// Pick all elements one by one` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{` `        `  `        ``// If already visited` `        ``if` `(vis[i] == 1)` `            ``continue``;` `            `  `        ``for``(``int` `j = i + 1; j < N; j++) ` `        ``{` `            `  `            ``// If already visited` `            ``if` `(vis[j] == 1)` `                ``continue``;`   `            ``// If difference is at least K` `            ``if` `(Math.Abs(arr[i] - arr[j]) >= K)` `            ``{` `                `  `                ``// Mark element as visited and` `                ``// increment the count` `                ``count++;` `                ``vis[i] = 1;` `                ``vis[j] = 1;` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// Print the final count` `    ``Console.Write(count);` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given arr[]` `    ``int``[] arr = { 1, 3, 3, 5 };`   `    ``// Size of array` `    ``int` `N = arr.Length;`   `    ``// Given difference K` `    ``int` `K = 2;`   `    ``// Function Call` `    ``countPairsWithDiffK(arr, N, K);` `}` `}`   `// This code is contributed by chitranayal`

Output
`2 `

Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: The efficient idea is to use Binary Search to find the first occurrence having a difference of at least K. Below are the steps:

• Sort the given array in increasing order.
• Initialize cnt to 0 that will store the count of all possible pairs.
• Perform the Binary Search as per the following:
• Initialize left as 0 and right as N/2 + 1.
• Find the value of mid as (left + right) / 2.
• Check if mid number of pairs can be formed by pairing leftmost M elements with rightmost M elements i.e., check if arr[0] – arr[N – M] ≥ d, arr[1] – arr[N -M + 1] ≥ d, …, arr[M – 1] – arr[N – 1] ≥ d.
• In the above steps, traverse the array over the range [0, M] and if there exists an index whose abs(arr[N – M + i] – arr[i]) is less than K then update right as (mid – 1).
• Otherwise, update left as mid + 1 and cnt as mid.
• After the above step, print the value of cnt as all possible count of pairs.

Below is the implementation of the above approach:

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to check if it is possible to` `// form M pairs with abs diff at least K` `bool` `isValid(``int` `arr[], ``int` `n, ``int` `m,` `             ``int` `d)` `{` `    ``// Traverse the array over [0, M]` `    ``for` `(``int` `i = 0; i < m; i++) {`   `        ``// If valid index` `        ``if` `(``abs``(arr[n - m + i]` `                ``- arr[i])` `            ``< d) {` `            ``return` `0;` `        ``}` `    ``}`   `    ``// Return 1` `    ``return` `1;` `}`   `// Function to count distinct pairs` `// with absolute difference atleasr K` `int` `countPairs(``int` `arr[], ``int` `N, ``int` `K)` `{` `    ``// Stores the count of all` `    ``// possible pairs` `    ``int` `ans = 0;`   `    ``// Initialize left and right` `    ``int` `left = 0, right = N / 2 + 1;`   `    ``// Sort the array` `    ``sort(arr, arr + N);`   `    ``// Perform Binary Search` `    ``while` `(left < right) {`   `        ``// Find the value of mid` `        ``int` `mid = (left + right) / 2;`   `        ``// Check valid index` `        ``if` `(isValid(arr, N, mid, K)) {`   `            ``// Update ans` `            ``ans = mid;` `            ``left = mid + 1;` `        ``}` `        ``else` `            ``right = mid - 1;` `    ``}`   `    ``// Print the answer` `    ``cout << ans << ``' '``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 1, 3, 3, 5 };`   `    ``// Given difference K` `    ``int` `K = 2;`   `    ``// Size of the array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function call` `    ``countPairs(arr, N, K);`   `    ``return` `0;` `}`

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{` ` `  `// Function to check if it is possible to` `// form M pairs with abs diff at least K` `static` `int` `isValid(``int` `arr[], ``int` `n, ``int` `m,` `                   ``int` `d)` `{` `    `  `    ``// Traverse the array over [0, M]` `    ``for``(``int` `i = ``0``; i < m; i++) ` `    ``{` `        `  `        ``// If valid index` `        ``if` `(Math.abs(arr[n - m + i] - arr[i]) < d)` `        ``{` `            ``return` `0``;` `        ``}` `    ``}`   `    ``// Return 1` `    ``return` `1``;` `}`   `// Function to count distinct pairs` `// with absolute difference atleasr K` `static` `void` `countPairs(``int` `arr[], ``int` `N, ``int` `K)` `{` `    `  `    ``// Stores the count of all` `    ``// possible pairs` `    ``int` `ans = ``0``;`   `    ``// Initialize left and right` `    ``int` `left = ``0``, right = N / ``2` `+ ``1``;`   `    ``// Sort the array` `    ``Arrays.sort(arr);`   `    ``// Perform Binary Search` `    ``while` `(left < right)` `    ``{` `        `  `        ``// Find the value of mid` `        ``int` `mid = (left + right) / ``2``;`   `        ``// Check valid index` `        ``if` `(isValid(arr, N, mid, K) == ``1``)` `        ``{` `            `  `            ``// Update ans` `            ``ans = mid;` `            ``left = mid + ``1``;` `        ``}` `        ``else` `            ``right = mid - ``1``;` `    ``}`   `    ``// Print the answer` `    ``System.out.print(ans);` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    `  `    ``// Given array arr[]` `    ``int` `arr[] = { ``1``, ``3``, ``3``, ``5` `};`   `    ``// Given difference K` `    ``int` `K = ``2``;`   `    ``// Size of the array` `    ``int` `N = arr.length;`   `    ``// Function call` `    ``countPairs(arr, N, K);` `}` `}`   `// This code is contributed by bgangwar59`

 `# Python3 program for the above approach`   `# Function to check if it is possible to` `# form M pairs with abs diff at least K` `def` `isValid(arr, n, m, d):` `    `  `    ``# Traverse the array over [0, M]` `    ``for` `i ``in` `range``(m):` `        `  `        ``# If valid index` `        ``if` `(``abs``(arr[n ``-` `m ``+` `i] ``-` `arr[i]) < d):` `            ``return` `0`   `    ``# Return 1` `    ``return` `1`   `# Function to count distinct pairs` `# with absolute difference atleasr K` `def` `countPairs(arr, N, K):` `    `  `    ``# Stores the count of all` `    ``# possible pairs` `    ``ans ``=` `0`   `    ``# Initialize left and right` `    ``left ``=` `0` `    ``right ``=` `N ``/``/` `2` `+` `1`   `    ``# Sort the array` `    ``arr.sort(reverse ``=` `False``)`   `    ``# Perform Binary Search` `    ``while` `(left < right):` `        `  `        ``# Find the value of mid` `        ``mid ``=` `(left ``+` `right) ``/``/` `2`   `        ``# Check valid index` `        ``if` `(isValid(arr, N, mid, K)):` `            `  `            ``# Update ans` `            ``ans ``=` `mid` `            ``left ``=` `mid ``+` `1` `        ``else``:` `            ``right ``=` `mid ``-` `1`   `    ``# Print the answer` `    ``print``(ans, end ``=` `"")`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array arr[]` `    ``arr ``=` `[ ``1``, ``3``, ``3``, ``5` `]`   `    ``# Given difference K` `    ``K ``=` `2`   `    ``# Size of the array` `    ``N ``=` `len``(arr)`   `    ``# Function call` `    ``countPairs(arr, N, K)`   `# This code is contributed by bgangwar59`

 `// C# program for the ` `// above approach` `using` `System;` `class` `GFG{` ` `  `// Function to check if it ` `// is possible to form M ` `// pairs with abs diff at ` `// least K` `static` `int` `isValid(``int` `[]arr, ``int` `n, ` `                   ``int` `m, ``int` `d)` `{    ` `  ``// Traverse the array over` `  ``// [0, M]` `  ``for``(``int` `i = 0; i < m; i++) ` `  ``{` `    ``// If valid index` `    ``if` `(Math.Abs(arr[n - m + i] - ` `                 ``arr[i]) < d)` `    ``{` `      ``return` `0;` `    ``}` `  ``}`   `  ``// Return 1` `  ``return` `1;` `}`   `// Function to count distinct ` `// pairs with absolute difference ` `// atleast K` `static` `void` `countPairs(``int` `[]arr, ` `                       ``int` `N, ``int` `K)` `{    ` `  ``// Stores the count of all` `  ``// possible pairs` `  ``int` `ans = 0;`   `  ``// Initialize left` `  ``// and right` `  ``int` `left = 0, ` `      ``right = N / 2 + 1;`   `  ``// Sort the array` `  ``Array.Sort(arr);`   `  ``// Perform Binary Search` `  ``while` `(left < right)` `  ``{` `    ``// Find the value of mid` `    ``int` `mid = (left + ` `               ``right) / 2;`   `    ``// Check valid index` `    ``if` `(isValid(arr, N, ` `                ``mid, K) == 1)` `    ``{` `      ``// Update ans` `      ``ans = mid;` `      ``left = mid + 1;` `    ``}` `    ``else` `      ``right = mid - 1;` `  ``}`   `  ``// Print the answer` `  ``Console.WriteLine(ans);` `}`   `// Driver Code` `public` `static` `void` `Main()` `{    ` `  ``// Given array arr[]` `  ``int` `[]arr = {1, 3, 3, 5};`   `  ``// Given difference K` `  ``int` `K = 2;`   `  ``// Size of the array` `  ``int` `N = arr.Length;`   `  ``// Function call` `  ``countPairs(arr, N, K);` `}` `}`   `// This code is contributed by surendra_gangwar`

Output
`2 `

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :