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]
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, 2): As 1 < 2, and 1*2 = 2*1 where L1 = 2 and L2 = 1.
- (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++
#include <bits/stdc++.h>
using namespace std;
void computeTotient( int N, int phi[])
{
for ( int p = 2; p <= N; p++) {
if (phi[p] == p) {
phi[p] = p - 1;
for ( int i = 2 * p; i <= N;
i += p) {
phi[i] = (phi[i] / p) * (p - 1);
}
}
}
}
void countPairs( int N)
{
int cnt_type1 = 0, cnt_type2 = 0;
int half_N = N / 2;
cnt_type1 = (half_N * (half_N - 1)) / 2;
int phi[N + 1];
for ( int i = 1; i <= N; i++) {
phi[i] = i;
}
computeTotient(N, phi);
for ( int i = (N / 2) + 1;
i <= N; i++)
cnt_type2 += (i - phi[i] - 1);
cout << cnt_type1 + cnt_type2;
}
int main()
{
int N = 6;
countPairs(N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void computeTotient( int N, int phi[])
{
for ( int p = 2 ; p <= N; p++)
{
if (phi[p] == p)
{
phi[p] = p - 1 ;
for ( int i = 2 * p; i <= N; i += p)
{
phi[i] = (phi[i] / p) * (p - 1 );
}
}
}
}
static void countPairs( int N)
{
int cnt_type1 = 0 , cnt_type2 = 0 ;
int half_N = N / 2 ;
cnt_type1 = (half_N * (half_N - 1 )) / 2 ;
int []phi = new int [N + 1 ];
for ( int i = 1 ; i <= N; i++)
{
phi[i] = i;
}
computeTotient(N, phi);
for ( int i = (N / 2 ) + 1 ;
i <= N; i++)
cnt_type2 += (i - phi[i] - 1 );
System.out.print(cnt_type1 + cnt_type2);
}
public static void main(String[] args)
{
int N = 6 ;
countPairs(N);
}
}
|
Python3
def computeTotient(N, phi):
for p in range ( 2 , N + 1 ):
if phi[p] = = p:
phi[p] = p - 1
for i in range ( 2 * p, N + 1 , p):
phi[i] = (phi[i] / / p) * (p - 1 )
def countPairs(N):
cnt_type1 = 0
cnt_type2 = 0
half_N = N / / 2
cnt_type1 = (half_N * (half_N - 1 )) / / 2
phi = [ 0 for i in range (N + 1 )]
for i in range ( 1 , N + 1 ):
phi[i] = i
computeTotient(N, phi)
for i in range ((N / / 2 ) + 1 , N + 1 ):
cnt_type2 + = (i - phi[i] - 1 )
print (cnt_type1 + cnt_type2)
if __name__ = = '__main__' :
N = 6
countPairs(N)
|
C#
using System;
class GFG {
static void computeTotient( int N, int [] phi)
{
for ( int p = 2; p <= N; p++) {
if (phi[p] == p) {
phi[p] = p - 1;
for ( int i = 2 * p; i <= N; i += p) {
phi[i] = (phi[i] / p) * (p - 1);
}
}
}
}
static void countPairs( int N)
{
int cnt_type1 = 0, cnt_type2 = 0;
int half_N = N / 2;
cnt_type1 = (half_N * (half_N - 1)) / 2;
int [] phi = new int [N + 1];
for ( int i = 1; i <= N; i++) {
phi[i] = i;
}
computeTotient(N, phi);
for ( int i = (N / 2) + 1; i <= N; i++)
cnt_type2 += (i - phi[i] - 1);
Console.Write(cnt_type1 + cnt_type2);
}
public static void Main()
{
int N = 6;
countPairs(N);
}
}
|
Javascript
<script>
function computeTotient(N, phi)
{
for (let p = 2; p <= N; p++)
{
if (phi[p] == p)
{
phi[p] = p - 1;
for (let i = 2 * p; i <= N; i += p)
{
phi[i] = (phi[i] / p) * (p - 1);
}
}
}
}
function countPairs(N)
{
let cnt_type1 = 0, cnt_type2 = 0;
let half_N = N / 2;
cnt_type1 = (half_N * (half_N - 1)) / 2;
let phi = Array.from({length: N+1}, (_, i) => 0);
for (let i = 1; i <= N; i++)
{
phi[i] = i;
}
computeTotient(N, phi);
for (let i = (N / 2) + 1;
i <= N; i++)
cnt_type2 += (i - phi[i] - 1);
document.write(cnt_type1 + cnt_type2);
}
let N = 6;
countPairs(N);
</script>
|
Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N), since N extra space has been taken.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...