# Count maximum number of disjoint pairs having one element not less than K times the other

• Difficulty Level : Easy
• Last Updated : 16 Aug, 2021

Given an array arr[] and a positive integer K, the task is to find the maximum count of disjoint pairs (arr[i], arr[j]) such that arr[j] ≥ K * arr[i].

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { 1, 9, 4, 7, 3 }, K = 2
Output: 2
Explanation:
There can be 2 possible pairs that can formed from the given array i.e., (4, 1) and (7, 3) that satisfy the given conditions.

Input: arr[] = {2, 3, 4, 5, 6, 7, 8, 9}, K = 3
Output: 2

Approach: The given problem can be solved by using the Two Pointer Approach. Follow the steps below to solve the given problem:

1. Sort the given array in increasing order.
2. Initialize two variables i and j as 0 and (N / 2) respectively and variable count that stores the resultant maximum count of pairs.
3. Traverse the given array over the range [0, N/2] and perform the following steps:
• Increment the value of j until j < N and arr[j] < K * arr[i].
• If the value of j is less than N, then increment the count of pairs by 1.
• Increment the value of j by 1.
4. After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum count``// of disjoint pairs such that arr[i]``// is at least K*arr[j]``int` `maximizePairs(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Sort the array``    ``sort(arr, arr + n);` `    ``// Initialize the two pointers``    ``int` `i = 0, j = n / 2;` `    ``// Stores the total count of pairs``    ``int` `count = 0;` `    ``for` `(i = 0; i < n / 2; i++) {` `        ``// Increment j until a valid``        ``// pair is found or end of the``        ``// array is reached``        ``while` `(j < n``               ``&& (k * arr[i]) > arr[j])``            ``j++;` `        ``// If j is not the end of the``        ``// array, then a valid pair``        ``if` `(j < n)``            ``count++;` `        ``j++;``    ``}` `    ``// Return the possible count``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 9, 4, 7, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `K = 2;``    ``cout << maximizePairs(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java code for above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum count``// of disjoint pairs such that arr[i]``// is at least K*arr[j]``static` `int` `maximizePairs(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Sort the array``    ``Arrays.sort(arr);` `    ``// Initialize the two pointers``    ``int` `i = ``0``, j = n / ``2``;` `    ``// Stores the total count of pairs``    ``int` `count = ``0``;` `    ``for` `(i = ``0``; i < n / ``2``; i++) {` `        ``// Increment j until a valid``        ``// pair is found or end of the``        ``// array is reached``        ``while` `(j < n``               ``&& (k * arr[i]) > arr[j])``            ``j++;` `        ``// If j is not the end of the``        ``// array, then a valid pair``        ``if` `(j < n)``            ``count++;` `        ``j++;``    ``}` `    ``// Return the possible count``    ``return` `count;``}` `// Driver Code``public` `static` `void` `main(String[] args)` `{``    ``int` `arr[] = { ``1``, ``9``, ``4``, ``7``, ``3` `};``    ``int` `N = arr.length;``    ``int` `K = ``2``;``    ``System.out.print(maximizePairs(arr, N, K));``}``}` `// This code is contributed by avijitmondal1998.`

## Python3

 `# Python 3 program for the above approach` `# Function to find the maximum count``# of disjoint pairs such that arr[i]``# is at least K*arr[j]``def` `maximizePairs(arr, n, k):``  ` `    ``# Sort the array``    ``arr.sort()` `    ``# Initialize the two pointers``    ``i ``=` `0``    ``j ``=` `n ``/``/` `2` `    ``# Stores the total count of pairs``    ``count ``=` `0` `    ``for` `i ``in` `range``(n``/``/``2``):``      ` `        ``# Increment j until a valid``        ``# pair is found or end of the``        ``# array is reached``        ``while` `(j < n ``and` `(k ``*` `arr[i]) > arr[j]):``            ``j ``+``=` `1` `        ``# If j is not the end of the``        ``# array, then a valid pair``        ``if` `(j < n):``            ``count ``+``=` `1` `        ``j ``+``=` `1` `    ``# Return the possible count``    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``1``, ``9``, ``4``, ``7``, ``3``]``    ``N ``=` `len``(arr)``    ``K ``=` `2``    ``print``(maximizePairs(arr, N, K))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# code for above approach``using` `System;` `class` `GFG{` `// Function to find the maximum count``// of disjoint pairs such that arr[i]``// is at least K*arr[j]``static` `int` `maximizePairs(``int` `[]arr, ``int` `n, ``int` `k)``{``    ``// Sort the array``    ``Array.Sort(arr);` `    ``// Initialize the two pointers``    ``int` `i = 0, j = n / 2;` `    ``// Stores the total count of pairs``    ``int` `count = 0;` `    ``for` `(i = 0; i < n / 2; i++) {` `        ``// Increment j until a valid``        ``// pair is found or end of the``        ``// array is reached``        ``while` `(j < n``               ``&& (k * arr[i]) > arr[j])``            ``j++;` `        ``// If j is not the end of the``        ``// array, then a valid pair``        ``if` `(j < n)``            ``count++;` `        ``j++;``    ``}` `    ``// Return the possible count``    ``return` `count;``}` `// Driver Code``public` `static` `void` `Main(String[] args)` `{``    ``int` `[]arr = { 1, 9, 4, 7, 3 };``    ``int` `N = arr.Length;``    ``int` `K = 2;``    ``Console.Write(maximizePairs(arr, N, K));``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``
Output:
`2`

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

My Personal Notes arrow_drop_up