不是n的除数的n平方的除数

给定一个正的大整数n。计算n ²的正除数的数量，该数不能被n(1 <= n <= 10 ¹² )的任何除数整除。

Input: 6
Output: 5
Explanation
Total divisors of 62 are 9 i.e.,
1, 2, 3, 4, 6, 9, 12, 18, 36
Total divisors of '6' are 4,
1, 2, 3, 6
Total divisor of '36' which are not
divisible by divisors of '6' are
'5' i.e., 4, 9, 12, 18, 36

Input: 8
Output: 3

一种简单的方法是遍历n ^2的每个除数，并仅计算那些不是’n’除数的除数。这种方法的时间复杂度为O(n)。

一种有效的方法是使用质因数分解来计算n ^2的总除数。数字“ n”可以表示为质数的乘积$p_1^{k_1} p_2^{k_2} \ldots p_n^{k_n}$ 。参考此以了解更多信息。

让$n = p_1^{k_1} p_2^{k_2}$对于一些素数p ₁和p ₂ 。双方平方$\implies n^2 = p_1^{2k_1} p_2^{2k_2}$ n ^2的总因子为$\implies (2k_1+1)(2k_2+1)$总因子“ n”为$\implies (k_1+1)(k_2+1)$两者之间的差异给出了所需的答案

C++

// C++ program to count number of
// divisors of n^2 which are not
// divisible by divisor of n
#include 
using namespace std;
  
// Function to count divisors of n^2
// having no factors of 'n'
int factors(long long n)
{
    unordered_map prime;
    for (int i = 2; i <= sqrt(n); ++i) {
        while (n % i == 0) {
  
            // Increment count of i-th prime divisor
            ++prime[i];
  
            // Find next  prime divisor
            n = n / i;
        }
    }
  
    // Increment count if divisor still remains
    if (n > 2)
        ++prime[n];
  
    // Initialize variable for counting the factors
    // of  n^2 and n as ans1 and ans2 respectively
    int ans1 = 1, ans2 = 1;
  
    // Range based for-loop
    for (auto it : prime) {
  
        // Use formula as discussed in above
        ans1 *= 2 * it.second + 1;
        ans2 *= it.second + 1;
    }
  
    // return the difference of answers
    return ans1 - ans2;
}
  
// Driver code
int main()
{
    long long n = 5;
    cout << factors(n) << endl;
    n = 8;
    cout << factors(n);
    return 0;
}

Java

// Java program to count number of
// divisors of n^2 which are not
// divisible by divisor of n
import java.util.*;
  
class GFG 
{
  
// Function to count divisors of n^2
// having no factors of 'n'
static int factors(int n)
{
    HashMapprime = new HashMap();
    for (int i = 2; i <= Math.sqrt(n); ++i) 
    {
        while (n % i == 0) 
        {
  
            // Increment count of i-th prime divisor
            if (prime.containsKey(i)) 
            {
                prime.put(i, prime.get(i) + 1);
            } 
              
            else 
            {
                prime.put(i, 1);
            }
  
            // Find next prime divisor
            n = n / i;
        }
    }
  
    // Increment count if divisor still remains
    if (n > 2)
    {
        if(prime.containsKey(n))
        {
            prime.put(n, prime.get(n) + 1);
        }
        else
        {
            prime.put(n, 1);
        }
    }
  
    // Initialize variable for counting the factors
    // of n^2 and n as ans1 and ans2 respectively
    int ans1 = 1, ans2 = 1;
  
    // Range based for-loop
    for (Map.Entry it : prime.entrySet()) 
    {
  
        // Use formula as discussed in above
        ans1 *= 2 * it.getValue() + 1;
        ans2 *= it.getValue() + 1;
    }
  
    // return the difference of answers
    return ans1 - ans2;
}
  
// Driver code
public static void main(String[] args) 
{
    int n = 5;
    System.out.println(factors(n));
    n = 8;
    System.out.println(factors(n));
}
}
  
// This code is contributed by PrinciRaj1992

Python3

# Python3 program to count number of
# divisors of n^2 which are not
# divisible by divisor of n
import math as mt
  
# Function to count divisors of n^2
# having no factors of 'n'
def factors(n):
  
    prime = dict()
    for i in range(2, mt.ceil(mt.sqrt(n + 1))):
        while (n % i == 0):
              
            # Increment count of i-th 
            # prime divisor
            if i in prime.keys():
                prime[i] += 1
            else:
                prime[i] = 1
                  
            # Find next prime divisor
            n = n // i
          
    # Increment count if divisor
    # still remains
    if (n > 2):
        if n in prime.keys():
            prime[n] += 1
        else:
            prime[n] = 1
  
    # Initialize variable for counting 
    # the factors of n^2 and n as ans1 
    # and ans2 respectively
    ans1 = 1
    ans2 = 1
  
    # Range based for-loop
    for it in prime:
  
        # Use formula as discussed in above
        ans1 *= 2 * prime[it] + 1
        ans2 *= prime[it] + 1
      
    # return the difference of answers
    return ans1 - ans2
  
# Driver code
n = 5
print(factors(n))
n = 8
print(factors(n))
  
# This code is contributed by 
# Mohit kumar 29

C#

// C# program to count number of
// divisors of n^2 which are not
// divisible by divisor of n
using System;
using System.Collections.Generic;
      
class GFG 
{
  
// Function to count divisors of n^2
// having no factors of 'n'
static int factors(int n)
{
    Dictionary prime = new Dictionary();
    for (int i = 2; i <= Math.Sqrt(n); ++i) 
    {
        while (n % i == 0) 
        {
  
            // Increment count of i-th prime divisor
            if (prime.ContainsKey(i)) 
            {
                prime[i] = prime[i] + 1;
            } 
              
            else
            {
                prime.Add(i, 1);
            }
  
            // Find next prime divisor
            n = n / i;
        }
    }
  
    // Increment count if divisor still remains
    if (n > 2)
    {
        if(prime.ContainsKey(n))
        {
            prime[n] = prime[n] + 1;
        }
        else
        {
            prime.Add(n, 1);
        }
    }
  
    // Initialize variable for counting the factors
    // of n^2 and n as ans1 and ans2 respectively
    int ans1 = 1, ans2 = 1;
  
    // Range based for-loop
    foreach(KeyValuePair it in prime) 
    {
  
        // Use formula as discussed in above
        ans1 *= 2 * it.Value + 1;
        ans2 *= it.Value + 1;
    }
  
    // return the difference of answers
    return ans1 - ans2;
}
  
// Driver code
public static void Main(String[] args) 
{
    int n = 5;
    Console.WriteLine(factors(n));
    n = 8;
    Console.WriteLine(factors(n));
}
}
  
// This code is contributed by Rajput-Ji

输出：

1
3

时间复杂度： O(sqrt(n))
辅助空间： O(1)