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

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: 1
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)

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to use the 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 are 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 it in array.
Example:

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

3. 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.
4. 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

Output:

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

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.