Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 11 Oct, 2022
Improve Article
Save Article

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:

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 <bits/stdc++.h>
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




<script>
// Javascript program for the above approach
 
// Function to find the maximum count
// of disjoint pairs such that arr[i]
// is at least K*arr[j]
function maximizePairs(arr, n, k) {
  // Sort the array
  arr.sort((a, b) => a - b);
 
  // Initialize the two pointers
  let i = 0,
    j = Math.floor(n / 2);
 
  // Stores the total count of pairs
  let count = 0;
 
  for (i = 0; i < Math.floor(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
 
let arr = [1, 9, 4, 7, 3];
let N = arr.length;
let K = 2;
document.write(maximizePairs(arr, N, K));
 
// This code is contributed by gfgking.
</script>

Output: 

2

 

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!