Skip to content
Related Articles

Related Articles

Count number of pairs (i, j) up to N that can be made equal on multiplying with a pair from the range [1, N / 2]

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 20 Jul, 2022

Given a positive even integer N, the task is to find the number of pairs (i, j) from the range [1, N] such that the product of i and L1 is the same as the product of j and L2 where i < j and L1 and L2 any number from the range [1, N/2].

Examples:

Input: N = 4
Output: 2
Explanation:
The possible pairs satisfying the given criteria are:

  1. (1, 2): As 1 < 2, and 1*2 = 2*1 where L1 = 2 and L2 = 1.
  2. (2, 4): As 2 < 4 and 2*2 = 4*1 where L1 = 2 and L2 = 1.

Therefore, the total count is 2.

Input: N = 6
Output: 7

Naive Approach: The given problem can be solved based on the following observations:

Let i * L1 = j * L2 = lcm(i, j) — (1)
⇒ L1 = lcm(i, j)/ i
= j/gcd(i, j)

Similarly, L2 = i/gcd(i, j)

Now, for the condition to be satisfied, L1 and L2 must be in the range [1, N/2].

Therefore, the idea is to generate all possible pairs (i, j) over the range [1,  N] and if there exist any pair (i, j) such that the value of i/gcd(i, j) and j/gcd(i, j) is less than N/2, then increment the count of pairs by 1. After checking for all the pairs, print the value of the count as the result.

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

Efficient Approach: The above approach can also be optimized by using Euler’s Totient function. There exist the following 2 cases for any pair (i, j):

  • Case 1: If the pair (i, j) lies in the range [1, N/2], then all the possible pairs formed will satisfy the given condition. Therefore, the total count of pairs is given by (z*(z – 1))/2, where z = N/2.
  • Case 2: If all possible pairs (i, j) lies in the range [N/2 + 1, N] having gcd(i, j) is greater than 1 satisfy the given conditions.

Follow the steps below to count the total number of this type of pairs:

  • Compute Φ for all numbers smaller than or equal to N by using Euler’s Totient function for all numbers smaller than or equal to N.
  • For a number j, the total number of possible pairs (i, j) can be calculated as (j – Φ(j) – 1).
  • For each number in the range [N/2 + 1, N], count the total number pairs using the above formula.
  • After completing the above steps, print the sum of values obtained in the above two steps 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 compute totient of all
// numbers smaller than or equal to N
void computeTotient(int N, int phi[])
{
    // Iterate over the range [2, N]
    for (int p = 2; p <= N; p++) {
 
        // If phi[p] is not computed
        // already, then p is prime
        if (phi[p] == p) {
 
            // Phi of a prime number
            // p is (p - 1)
            phi[p] = p - 1;
 
            // Update phi values of
            // all multiples of p
            for (int i = 2 * p; i <= N;
                 i += p) {
 
                // Add contribution of p
                // to its multiple i by
                // multiplying with (1 - 1/p)
                phi[i] = (phi[i] / p) * (p - 1);
            }
        }
    }
}
 
// Function to count the pairs (i, j)
// from the range [1, N], satisfying
// the given condition
void countPairs(int N)
{
    // Stores the counts of first and
    // second type of pairs respectively
    int cnt_type1 = 0, cnt_type2 = 0;
 
    // Count of first type of pairs
    int half_N = N / 2;
    cnt_type1 = (half_N * (half_N - 1)) / 2;
 
    // Stores the  phi or totient values
    int phi[N + 1];
 
    for (int i = 1; i <= N; i++) {
        phi[i] = i;
    }
 
    // Calculate the Phi values
    computeTotient(N, phi);
 
    // Iterate over the range
    // [N/2 + 1, N]
    for (int i = (N / 2) + 1;
         i <= N; i++)
 
        // Update the value of
        // cnt_type2
        cnt_type2 += (i - phi[i] - 1);
 
    // Print the total count
    cout << cnt_type1 + cnt_type2;
}
 
// Driver Code
int main()
{
    int N = 6;
    countPairs(N);
 
    return 0;
}

Java



// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to compute totient of all
// numbers smaller than or equal to N
static void computeTotient(int N, int phi[])
{
     
    // Iterate over the range [2, N]
    for(int p = 2; p <= N; p++)
    {
         
        // If phi[p] is not computed
        // already, then p is prime
        if (phi[p] == p)
        {
             
            // Phi of a prime number
            // p is (p - 1)
            phi[p] = p - 1;
 
            // Update phi values of
            // all multiples of p
            for(int i = 2 * p; i <= N; i += p)
            {
                 
                // Add contribution of p
                // to its multiple i by
                // multiplying with (1 - 1/p)
                phi[i] = (phi[i] / p) * (p - 1);
            }
        }
    }
}
 
// Function to count the pairs (i, j)
// from the range [1, N], satisfying
// the given condition
static void countPairs(int N)
{
     
    // Stores the counts of first and
    // second type of pairs respectively
    int cnt_type1 = 0, cnt_type2 = 0;
 
    // Count of first type of pairs
    int half_N = N / 2;
    cnt_type1 = (half_N * (half_N - 1)) / 2;
 
    // Stores the  phi or totient values
    int []phi = new int[N + 1];
 
    for(int i = 1; i <= N; i++)
    {
        phi[i] = i;
    }
 
    // Calculate the Phi values
    computeTotient(N, phi);
 
    // Iterate over the range
    // [N/2 + 1, N]
    for(int i = (N / 2) + 1;
            i <= N; i++)
 
        // Update the value of
        // cnt_type2
        cnt_type2 += (i - phi[i] - 1);
 
    // Print the total count
    System.out.print(cnt_type1 + cnt_type2);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 6;
     
    countPairs(N);
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program for the above approach
 
# Function to compute totient of all
# numbers smaller than or equal to N
def computeTotient(N, phi):
 
    # Iterate over the range [2, N]
    for p in range(2, N + 1):
 
        # If phi[p] is not computed
        # already then p is prime
        if phi[p] == p:
 
            # Phi of a prime number
            # p is (p - 1)
            phi[p] = p - 1
 
            # Update phi values of
            # all multiples of p
            for i in range(2 * p, N + 1, p):
 
                # Add contribution of p
                # to its multiple i by
                # multiplying with (1 - 1/p)
                phi[i] = (phi[i] // p) * (p - 1)
 
# Function to count the pairs (i, j)
# from the range [1, N], satisfying
# the given condition
def countPairs(N):
 
    # Stores the counts of first and
    # second type of pairs respectively
    cnt_type1 = 0
    cnt_type2 = 0
 
    # Count of first type of pairs
    half_N = N // 2
    cnt_type1 = (half_N * (half_N - 1)) // 2
 
    # Count of second type of pairs
 
    # Stores the  phi or totient values
    phi = [0 for i in range(N + 1)]
 
    for i in range(1, N + 1):
        phi[i] = i
 
    # Calculate the Phi values
    computeTotient(N, phi)
 
    # Iterate over the range
    # [N/2 + 1, N]
    for i in range((N // 2) + 1, N + 1):
 
        # Update the value of
        # cnt_type2
        cnt_type2 += (i - phi[i] - 1)
 
    # Print the total count
    print(cnt_type1 + cnt_type2)
 
# Driver Code
if __name__ == '__main__':
 
    N = 6
    countPairs(N)
 
    # This code is contributed by kundudinesh007.
C#



// C# program for the above approach
 
using System;
class GFG {
    // Function to compute totient of all
    // numbers smaller than or equal to N
    static void computeTotient(int N, int[] phi)
    {
        // Iterate over the range [2, N]
        for (int p = 2; p <= N; p++) {
 
            // If phi[p] is not computed
            // already, then p is prime
            if (phi[p] == p) {
 
                // Phi of a prime number
                // p is (p - 1)
                phi[p] = p - 1;
 
                // Update phi values of
                // all multiples of p
                for (int i = 2 * p; i <= N; i += p) {
 
                    // Add contribution of p
                    // to its multiple i by
                    // multiplying with (1 - 1/p)
                    phi[i] = (phi[i] / p) * (p - 1);
                }
            }
        }
    }
 
    // Function to count the pairs (i, j)
    // from the range [1, N], satisfying
    // the given condition
    static void countPairs(int N)
    {
        // Stores the counts of first and
        // second type of pairs respectively
        int cnt_type1 = 0, cnt_type2 = 0;
 
        // Count of first type of pairs
        int half_N = N / 2;
        cnt_type1 = (half_N * (half_N - 1)) / 2;
 
        // Stores the  phi or totient values
        int[] phi = new int[N + 1];
 
        for (int i = 1; i <= N; i++) {
            phi[i] = i;
        }
 
        // Calculate the Phi values
        computeTotient(N, phi);
 
        // Iterate over the range
        // [N/2 + 1, N]
        for (int i = (N / 2) + 1; i <= N; i++)
 
            // Update the value of
            // cnt_type2
            cnt_type2 += (i - phi[i] - 1);
 
        // Print the total count
        Console.Write(cnt_type1 + cnt_type2);
    }
 
    // Driver Code
    public static void Main()
    {
        int N = 6;
        countPairs(N);
    }
}
 
// This code is contributed by ukasp.
Javascript



<script>
 
// Javascript program implementation
// of the approach
 
// Function to compute totient of all
// numbers smaller than or equal to N
function computeTotient(N, phi)
{
      
    // Iterate over the range [2, N]
    for(let p = 2; p <= N; p++)
    {
          
        // If phi[p] is not computed
        // already, then p is prime
        if (phi[p] == p)
        {
              
            // Phi of a prime number
            // p is (p - 1)
            phi[p] = p - 1;
  
            // Update phi values of
            // all multiples of p
            for(let i = 2 * p; i <= N; i += p)
            {
                  
                // Add contribution of p
                // to its multiple i by
                // multiplying with (1 - 1/p)
                phi[i] = (phi[i] / p) * (p - 1);
            }
        }
    }
}
  
// Function to count the pairs (i, j)
// from the range [1, N], satisfying
// the given condition
function countPairs(N)
{
      
    // Stores the counts of first and
    // second type of pairs respectively
    let cnt_type1 = 0, cnt_type2 = 0;
  
    // Count of first type of pairs
    let half_N = N / 2;
    cnt_type1 = (half_N * (half_N - 1)) / 2;
  
    // Stores the  phi or totient values
    let phi = Array.from({length: N+1}, (_, i) => 0);
  
    for(let i = 1; i <= N; i++)
    {
        phi[i] = i;
    }
  
    // Calculate the Phi values
    computeTotient(N, phi);
  
    // Iterate over the range
    // [N/2 + 1, N]
    for(let i = (N / 2) + 1;
            i <= N; i++)
  
        // Update the value of
        // cnt_type2
        cnt_type2 += (i - phi[i] - 1);
  
    // Print the total count
    document.write(cnt_type1 + cnt_type2);
}
 
// Driver Code
     
    let N = 6;
      
    countPairs(N);
  
 // This code is contributed by souravghosh0416.
</script>
Output: 
7
 
Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes
arrow_drop_up
Previous
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
Next

Minimum product modulo N possible for any pair from a given range
Recommended Articles
Page :
Check if elements of array can be made equal by multiplying given prime numbers
20, Feb 17
Count N-length arrays made from first M natural numbers whose subarrays can be made palindromic by replacing less than half of its elements
16, Dec 20
Check if all elements of a Circular Array can be made equal by increments of adjacent pairs
18, Aug 20
Count N-digit numbers made up of X or Y whose sum of digits is also made up of X or Y
06, Nov 20
Make two numbers equal by multiplying with their prime factors minimum number of times
17, Jun 21
Count of quadruples with product of a pair equal to the product of the remaining pair
08, Feb 21
Maximize product of a matrix by repeatedly multiplying pairs of adjacent cells with -1
16, May 21
Maximize matrix sum by repeatedly multiplying pairs of adjacent elements with -1
14, Feb 21
Find the player to reach at least N by multiplying with any value from given range
24, Jan 21
Check if N can be obtained from 1 by repetitively multiplying by 10 or 20
25, Jun 20
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Check if all elements of the given array can be made 0 by decrementing value in pairs
28, Feb 20
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Check whether an array can be made strictly increasing by incrementing and decrementing adjacent pairs
09, Dec 21
Check if GCD of Array can be made greater than 1 by replacing pairs with their products
29, Jan 22
Check if GCD of [L, R] can be made >1 by replacing pairs with their product at most K times
18, Feb 22
Count pairs from a given range whose sum is a Prime Number in that range
11, Nov 20
Count pairs from an array having GCD equal to the minimum element in the pair
27, Apr 21
Count of pairs in a given range with sum of their product and sum equal to their concatenated number
14, Jun 20
Count numbers from a given range that can be visited moving any number of steps from the range [L, R]
27, Jul 21
Check if N and M can be made equal by increasing N by A and decreasing M by B
18, Mar 20
Smallest positive integer K such that all array elements can be made equal by incrementing or decrementing by at most K
15, Jan 21
Check if sum of array can be made equal to X by removing either the first or last digits of every array element
23, Mar 21
Check if two coordinates can be made equal by incrementing/decrementing by K1 and K2 respectively
17, Aug 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
kundudinesh007
@kundudinesh007
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!