欧拉Totient值比自身小1的元素数

给定一个由N个整数组成的数组arr [] ，范围为L到R ，任务是查找满足以下条件的从索引L到R的数组中的元素总数：

$F(arr[i]) = arr[i] - 1$

where F(x) is Euler’s Totient Function.

例子：

Input: arr[] = {2, 4, 5, 8}, L = 1, R = 3 
Output: 2 
Explanation: 
Here in the given range, F(2) = 1 and (2 – 1) = 1. Similarly, F(5) = 4 and (5 – 1) = 4. 
So the total count of indices which satisfy the condition is 2. 

Input: arr[] = {9, 3, 4, 6, 8}, L = 3, R = 5 
Output: 0 
Explanation : 
In the given range there is no element that satisfies the given condition. 
So the total count is 0.

幼稚的方法：解决此问题的幼稚的方法是遍历数组的所有元素，并检查当前元素的欧拉Totient值是否比自身小1。如果是，则增加计数。
时间复杂度： O(N * sqrt(N))
辅助空间： O(1)

高效方法：

Euler’s Totient function F(n) for an input n is the count of numbers in {1, 2, 3, …, n} that are relatively prime to n, i.e., the numbers whose Greatest Common Divisor with n is 1.

1. 如果我们观察到，我们可以注意到上述给定条件仅由质数满足。
2. 因此，我们要做的就是计算给定范围内素数的总数。
3. 我们将使用Eratosthenes的Sieve来有效地计算素数。
4. 同样，我们将预先计算计数数组中素数的数量。

下面是上述方法的实现。

C++

// C++ program for the above approach
#include 
using namespace std;
  
long long prime[1000001] = { 0 };
  
// Seiev of Erotosthenes method to
// compute all primes
void seiveOfEratosthenes()
{
  
    for (int i = 2; i < 1000001;
         i++) {
        prime[i] = 1;
    }
  
    for (int i = 2; i * i < 1000001;
         i++) {
  
        // If current number is
        // marked prime then mark
        // its multiple as non-prime
        if (prime[i] == 1) {
            for (int j = i * i;
                 j < 1000001; j += i) {
                prime[j] = 0;
            }
        }
    }
}
  
// Function to count the number
// of element satisfying the condition
void CountElements(int arr[],
                   int n, int L,
                   int R)
{
    seiveOfEratosthenes();
  
    long long countPrime[n + 1]
        = { 0 };
  
    // Compute the number of primes
    // in count prime array
    for (int i = 1; i <= n; i++) {
        countPrime[i] = countPrime[i - 1]
                        + prime[arr[i - 1]];
    }
  
    // Print the number of elements
    // satisfying the condition
    cout << countPrime[R]
                - countPrime[L - 1]
         << endl;
  
    return;
}
  
// Driver Code
int main()
{
  
    // Given array
    int arr[] = { 2, 4, 5, 8 };
  
    // Size of the array
    int N = sizeof(arr) / sizeof(int);
    int L = 1, R = 3;
  
    // Function Call
    CountElements(arr, N, L, R);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
  
class GFG{
  
static int prime[] = new int[1000001];
  
// Seiev of Erotosthenes method to
// compute all primes
static void seiveOfEratosthenes()
{
    for(int i = 2; i < 1000001; i++)
    {
       prime[i] = 1;
    }
  
    for(int i = 2; i * i < 1000001; i++)
    {
         
       // If current number is
       // marked prime then mark
       // its multiple as non-prime
       if (prime[i] == 1)
       {
           for(int j = i * i; 
                   j < 1000001; j += i)
           {
              prime[j] = 0;
           }
       }
    }
}
  
// Function to count the number
// of element satisfying the condition
static void CountElements(int arr[], int n, 
                          int L, int R)
{
    seiveOfEratosthenes();
  
    int countPrime[] = new int[n + 1];
  
    // Compute the number of primes
    // in count prime array
    for(int i = 1; i <= n; i++)
    {
       countPrime[i] = countPrime[i - 1] + 
                        prime[arr[i - 1]];
    }
  
    // Print the number of elements
    // satisfying the condition
    System.out.print(countPrime[R] -
                     countPrime[L - 1] + "\n");
  
    return;
}
  
// Driver Code
public static void main(String[] args)
{
      
    // Given array
    int arr[] = { 2, 4, 5, 8 };
  
    // Size of the array
    int N = arr.length;
    int L = 1, R = 3;
  
    // Function Call
    CountElements(arr, N, L, R);
}
}
  
// This code is contributed by amal kumar choubey

Python3

# Python3 program for the above approach
prime = [0] * (1000001)
  
# Seiev of Erotosthenes method to
# compute all primes
def seiveOfEratosthenes():
  
    for i in range(2, 1000001):
        prime[i] = 1
      
    i = 2
    while(i * i < 1000001):
  
        # If current number is
        # marked prime then mark
        # its multiple as non-prime
        if (prime[i] == 1):
            for j in range(i * i, 1000001, i):
                prime[j] = 0
          
        i += 1
  
# Function to count the number
# of element satisfying the condition
def CountElements(arr, n, L, R):
      
    seiveOfEratosthenes()
  
    countPrime = [0] * (n + 1)
  
    # Compute the number of primes
    # in count prime array
    for i in range(1, n + 1):
        countPrime[i] = (countPrime[i - 1] + 
                          prime[arr[i - 1]])
      
    # Print the number of elements
    # satisfying the condition
    print(countPrime[R] - 
          countPrime[L - 1])
  
    return
  
# Driver Code
  
# Given array
arr = [ 2, 4, 5, 8 ]
  
# Size of the array
N = len(arr)
L = 1
R = 3
  
# Function call
CountElements(arr, N, L, R)
  
# This code is contributed by sanjoy_62

C#

// C# program for the above approach
using System;
class GFG{
  
static int []prime = new int[1000001];
  
// Seiev of Erotosthenes method to
// compute all primes
static void seiveOfEratosthenes()
{
    for(int i = 2; i < 1000001; i++)
    {
        prime[i] = 1;
    }
  
    for(int i = 2; i * i < 1000001; i++)
    {
          
        // If current number is
        // marked prime then mark
        // its multiple as non-prime
        if (prime[i] == 1)
        {
            for(int j = i * i; 
                    j < 1000001; j += i)
            {
                prime[j] = 0;
            }
        }
    }
}
  
// Function to count the number
// of element satisfying the condition
static void CountElements(int []arr, int n, 
                          int L, int R)
{
    seiveOfEratosthenes();
  
    int []countPrime = new int[n + 1];
  
    // Compute the number of primes
    // in count prime array
    for(int i = 1; i <= n; i++)
    {
        countPrime[i] = countPrime[i - 1] + 
                         prime[arr[i - 1]];
    }
  
    // Print the number of elements
    // satisfying the condition
    Console.Write(countPrime[R] -
                  countPrime[L - 1] + "\n");
  
    return;
}
  
// Driver Code
public static void Main(String[] args)
{
      
    // Given array
    int []arr = { 2, 4, 5, 8 };
  
    // Size of the array
    int N = arr.Length;
    int L = 1, R = 3;
  
    // Function Call
    CountElements(arr, N, L, R);
}
}
  
// This code is contributed by sapnasingh4991

输出：

2

时间复杂度： O(N * log(logN))
辅助空间： O(N)