# Count of pairs upto N such whose LCM is not equal to their product for Q queries

• Last Updated : 17 Nov, 2021

Given a number N, the task is to find the number of pairs (a, b) in the range [1, N] such that their LCM is not equal to their product, i.e. LCM(a, b) != (a*b) and (b > a). There can be multiple queries to answer.

Examples:

Input: Q[] = {5}
Output:
Explanation:
The pair from 1 to 5 is (2, 4)
Input: Q[] = {5, 7}
Output: 1, 4
Explanation:
The pair from 1 to 5 is (2, 4)
The pairs from 1 to 7 are (2, 4), (2, 6), (3, 6), (4, 6)

Approach: The idea is to use Euler’s Totient Function

1. Find the total number of pairs that can be formed using numbers from 1 to N. The number of pairs formed is equal to (N * (N – 1)) / 2.

2. For each integer i ≤ N, using Euler’s Totient Function find all such pairs which are co-prime with i and store them in the array.

Example:

```arr[10] = 10 * (1-1/2) * (1-1/5)
= 4```

3.

4. Now build the prefix sum table which stores the sum of all phi(i) for all i between 1 to N. Using this, we can answer each query in O(1) time.

5. Finally, the answer for any i ≤ N is given by the difference between the total number of pairs formed and pref[i].

Below is the implementation of the given approach:

## C++

 `// C++ program to find the count of pairs``// from 1 to N such that their LCM``// is not equal to their product``#include ``using` `namespace` `std;` `#define N 100005` `// To store Euler's Totient Function``int` `phi[N];` `// To store prefix sum table``int` `pref[N];` `// Compute Totients of all numbers``// smaller than or equal to N``void` `precompute()``{``    ``// Make phi[1]=0 since 1 cannot form any pair``    ``phi[1] = 0;` `    ``// Initialise all remaining phi[] with i``    ``for` `(``int` `i = 2; i < N; i++)``        ``phi[i] = i;` `    ``// Compute remaining phi``    ``for` `(``int` `p = 2; p < N; p++) {` `        ``// If phi[p] is not computed already,``        ``// then number p is prime``        ``if` `(phi[p] == p) {` `            ``// phi of prime number is p-1``            ``phi[p] = p - 1;` `            ``// Update phi of all multiples of p``            ``for` `(``int` `i = 2 * p; i < N; i += p) {` `                ``// Add the contribution of p``                ``// to its multiple i by multiplying``                ``// it with (1 - 1/p)``                ``phi[i] = (phi[i] / p) * (p - 1);``            ``}``        ``}``    ``}``}` `// Function to store prefix sum table``void` `prefix()``{``    ``// Prefix Sum of all Euler's Totient Values``    ``for` `(``int` `i = 1; i < N; i++)``        ``pref[i] = pref[i - 1] + phi[i];``}` `void` `find_pairs(``int` `n)``{` `    ``// Total number of pairs that can be formed``    ``int` `total = (n * (n - 1)) / 2;` `    ``int` `ans = total - pref[n];` `    ``cout << ``"Number of pairs from 1 to "``         ``<< n << ``" are "` `<< ans << endl;``}` `// Driver Code``int` `main()``{` `    ``// Function call to compute all phi``    ``precompute();` `    ``// Function call to store all prefix sum``    ``prefix();` `    ``int` `q[] = { 5, 7 };``    ``int` `n = ``sizeof``(q) / ``sizeof``(q[0]);` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``find_pairs(q[i]);``    ``}` `    ``return` `0;``}`

## Java

 `// Java program to find the count of pairs``// from 1 to N such that their LCM``// is not equal to their product` `class` `GFG{` `static` `final` `int` `N = ``100005``;` `// To store Euler's Totient Function``static` `int` `[]phi = ``new` `int``[N];` `// To store prefix sum table``static` `int` `[]pref = ``new` `int``[N];` `// Compute Totients of all numbers``// smaller than or equal to N``static` `void` `precompute()``{``    ``// Make phi[1] = 0 since 1 cannot form any pair``    ``phi[``1``] = ``0``;` `    ``// Initialise all remaining phi[] with i``    ``for` `(``int` `i = ``2``; i < N; i++)``        ``phi[i] = i;` `    ``// Compute remaining phi``    ``for` `(``int` `p = ``2``; p < N; p++) {` `        ``// If phi[p] is not computed already,``        ``// then number p is prime``        ``if` `(phi[p] == p) {` `            ``// phi of prime number is p-1``            ``phi[p] = p - ``1``;` `            ``// Update phi of all multiples of p``            ``for` `(``int` `i = ``2` `* p; i < N; i += p) {` `                ``// Add the contribution of p``                ``// to its multiple i by multiplying``                ``// it with (1 - 1/p)``                ``phi[i] = (phi[i] / p) * (p - ``1``);``            ``}``        ``}``    ``}``}` `// Function to store prefix sum table``static` `void` `prefix()``{``    ``// Prefix Sum of all Euler's Totient Values``    ``for` `(``int` `i = ``1``; i < N; i++)``        ``pref[i] = pref[i - ``1``] + phi[i];``}` `static` `void` `find_pairs(``int` `n)``{` `    ``// Total number of pairs that can be formed``    ``int` `total = (n * (n - ``1``)) / ``2``;` `    ``int` `ans = total - pref[n];` `    ``System.out.print(``"Number of pairs from 1 to "``        ``+ n + ``" are "` `+ ans +``"\n"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{` `    ``// Function call to compute all phi``    ``precompute();` `    ``// Function call to store all prefix sum``    ``prefix();` `    ``int` `q[] = { ``5``, ``7` `};``    ``int` `n = q.length;` `    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``find_pairs(q[i]);``    ``}` `}``}` `// This code contributed by Rajput-Ji`

## Python3

 `# Python 3 program to find the count of pairs``# from 1 to N such that their LCM``# is not equal to their product` `N ``=` `100005` `# To store Euler's Totient Function``phi ``=` `[``0` `for` `i ``in` `range``(N)]` `# To store prefix sum table``pref ``=` `[``0` `for` `i ``in` `range``(N)]` `# Compute Totients of all numbers``# smaller than or equal to N``def` `precompute():` `    ``# Make phi[1]=0 since 1 cannot form any pair``    ``phi[``1``] ``=` `0` `    ``# Initialise all remaining phi[] with i``    ``for` `i ``in` `range``(``2``, N, ``1``):``        ``phi[i] ``=` `i` `    ``# Compute remaining phi``    ``for` `p ``in` `range``(``2``,N):``        ``# If phi[p] is not computed already,``        ``# then number p is prime``        ``if` `(phi[p] ``=``=` `p):``            ``# phi of prime number is p-1``            ``phi[p] ``=` `p ``-` `1` `            ``# Update phi of all multiples of p``            ``for` `i ``in` `range``(``2``*``p, N, p):` `                ``# Add the contribution of p``                ``# to its multiple i by multiplying``                ``# it with (1 - 1/p)``                ``phi[i] ``=` `(phi[i] ``/``/` `p) ``*` `(p ``-` `1``)` `# Function to store prefix sum table``def` `prefix():` `    ``# Prefix Sum of all Euler's Totient Values``    ``for` `i ``in` `range``(``1``, N, ``1``):``        ``pref[i] ``=` `pref[i ``-` `1``] ``+` `phi[i]` `def` `find_pairs(n):``    ``# Total number of pairs that can be formed``    ``total ``=` `(n ``*` `(n ``-` `1``)) ``/``/` `2` `    ``ans ``=` `total ``-` `pref[n]` `    ``print``(``"Number of pairs from 1 to"``,n,``"are"``,ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Function call to compute all phi``    ``precompute()` `    ``# Function call to store all prefix sum``    ``prefix()` `    ``q ``=`  `[``5``, ``7``]``    ``n ``=` `len``(q)` `    ``for` `i ``in` `range``(n):``        ``find_pairs(q[i])``        ` `# This code is contributed by Surendra_Gangwar`

## C#

 `// C# program to find the count of pairs``// from 1 to N such that their LCM``// is not equal to their product``using` `System;` `class` `GFG{` `static` `readonly` `int` `N = 100005;` `// To store Euler's Totient Function``static` `int` `[]phi = ``new` `int``[N];` `// To store prefix sum table``static` `int` `[]pref = ``new` `int``[N];` `// Compute Totients of all numbers``// smaller than or equal to N``static` `void` `precompute()``{` `    ``// Make phi[1] = 0 since 1``    ``// cannot form any pair``    ``phi[1] = 0;` `    ``// Initialise all remaining``    ``// phi[] with i``    ``for``(``int` `i = 2; i < N; i++)``       ``phi[i] = i;` `    ``// Compute remaining phi``    ``for``(``int` `p = 2; p < N; p++)``    ``{``       ` `       ``// If phi[p] is not computed already,``       ``// then number p is prime``       ``if` `(phi[p] == p)``       ``{``           ` `           ``// phi of prime number is p-1``           ``phi[p] = p - 1;``           ` `           ``// Update phi of all multiples of p``           ``for``(``int` `i = 2 * p; i < N; i += p)``           ``{``              ` `              ``// Add the contribution of p``              ``// to its multiple i by multiplying``              ``// it with (1 - 1/p)``              ``phi[i] = (phi[i] / p) * (p - 1);``           ``}``       ``}``    ``}``}` `// Function to store prefix sum table``static` `void` `prefix()``{``    ` `    ``// Prefix Sum of all``    ``// Euler's Totient Values``    ``for``(``int` `i = 1; i < N; i++)``       ``pref[i] = pref[i - 1] + phi[i];``}` `static` `void` `find_pairs(``int` `n)``{` `    ``// Total number of pairs``    ``// that can be formed``    ``int` `total = (n * (n - 1)) / 2;``    ``int` `ans = total - pref[n];` `    ``Console.Write(``"Number of pairs from 1 to "` `+``                      ``n + ``" are "` `+ ans + ``"\n"``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{` `    ``// Function call to compute all phi``    ``precompute();` `    ``// Function call to store``    ``// all prefix sum``    ``prefix();` `    ``int` `[]q = {5, 7};``    ``int` `n = q.Length;` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``       ``find_pairs(q[i]);``    ``}``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

```Number of pairs from 1 to 5 are 1
Number of pairs from 1 to 7 are 4```

Time Complexity: O(n2)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up