📜  前n个自然数的不同素数的数量

📅  最后修改于: 2021-06-26 21:00:44             🧑  作者: Mango

在本文中,我们研究了一种使用O O(n * log n)时间复杂度并允许预先计算的方法来计算高达n个自然数的独特素数分解的一种优化方法。
先决条件: Eratosthenes筛,直到n的数字的最小素因数。

为了计算每个数字的最小素因数,我们将使用eratosthenes的筛子。在原始的Sieve中,每次我们将数字标记为非质数时,我们都会为该数字存储相应的最小质数(请参阅本文以获得更好的理解)。
上述方法的实现如下:

C++
// C++ program to find prime factorization upto n natural number
// O(n*Log n) time with precomputation
#include 
using namespace std;
#define MAXN 100001
 
// Stores smallest prime factor for every number
int spf[MAXN];
 
// Adjacency vector to store distinct prime factors
vectoradj[MAXN];
 
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
void sieve()
{
    spf[1] = 1;
        // marking smallest prime factor for every
        // number to be itself.
    for (int i=2; i


Java
// Java program to find prime factorization upto n natural number
// O(n*Log n) time with precomputation
import java.io.*;
import java.util.*;
class GFG
{
    static int MAXN = 100001;
     
    // Stores smallest prime factor for every number
    static int[] spf = new int[MAXN];
   
    // Adjacency vector to store distinct prime factors
    static ArrayList> adj =
      new ArrayList>();
     
    // Calculating SPF (Smallest Prime Factor) for every
    // number till MAXN.
    // Time Complexity : O(nloglogn)
    static void sieve()
    {
        for(int i = 0; i < MAXN; i++)
        {
            adj.add(new ArrayList());
        }
        spf[1] = 1;
       
        // marking smallest prime factor for every
        // number to be itself.
        for (int i = 2; i < MAXN; i++)
        {
            spf[i] = i;
        }
        for (int i = 2; i * i < MAXN; i++)
        {
            // checking if i is prime
        if (spf[i] == i)
        {
                // marking SPF for all numbers divisible by i
                for (int j = i * i; j < MAXN; j += i)
                {
                   
                    // marking spf[j] if it is not
                    // previously marked
                    if (spf[j] == j)
                        spf[j] = i;
                }
            }
        }
    }
     
    // A O(nlog n) function returning distinct primefactorization
    // upto n natural number by dividing by smallest prime factor
    // at every step   
    static void getdistinctFactorization(int n)
    {
        int index, x, i;
        for(i = 1; i <= n; i++)
        {
            index = 1;
            x = i;
            if(x != 1)
                adj.get(i).add(spf[x]);
            x = x / spf[x];
           
            // Push all distinct prime factor in adj
            while (x != 1)
            {
                if (adj.get(i).get(index - 1) != spf[x])
                {
                    adj.get(i).add(spf[x]);
                    index += 1;
                }
                x = x / spf[x];
            }
        }
    }
   
    // Driver code
    public static void main (String[] args)
    {
       
        // Precalculating smallest prime factor
        sieve();    
        int n = 10;    
        getdistinctFactorization(n);
      
        // Print the prime count
        System.out.print("Distinct prime factor for first " +
                         n + " natural number" + " : ");
        for (int i = 1; i <= n; i++)
        {
            System.out.print(adj.get(i).size()+ " ");
        }
    }
}
 
// This code is contributed by avanitrachhadiya2155


Python3
# Python3 program to find prime factorization upto n natural number
# O(n*Log n) time with precomputation
 
# Calculating SPF (Smallest Prime Factor) for every
# number till MAXN.
# Time Complexity : O(nloglogn)
def sieve():
    global spf, adj, MAXN
    spf[1] = 1
     
    # marking smallest prime factor for every
    # number to be itself.
    for i in range(2, MAXN):
        spf[i] = i
 
    for i in range(2, MAXN):
        if i * i > MAXN:
            break
             
        # checking if i is prime
        if (spf[i] == i):
           
            # marking SPF for all numbers divisible by i
            for j in range(i * i, MAXN, i):
 
                # marking spf[j] if it is not
                # previously marked
                if (spf[j] == j):
                    spf[j] = i
 
# A O(nlog n) function returning distinct primefactorization
# upto n natural number by dividing by smallest prime factor
# at every step
def getdistinctFactorization(n):
    global adj, spf, MAXN
    index = 0
    for i in range(1, n + 1):
        index = 1
        x = i
        if(x != 1):
            adj[i].append(spf[x])
        x = x // spf[x]
         
        # Push all distinct prime factor in adj
        while (x != 1):
            if (adj[i][index - 1] != spf[x]):
                adj[i].append(spf[x])
                index += 1
            x = x // spf[x]
 
# Driver code
if __name__ == '__main__':
    MAXN = 100001
    spf = [0 for i in range(MAXN)]
    adj = [[] for i in range(MAXN)]
     
    # Precalculating smallest prime factor
    sieve()
    n = 10
    getdistinctFactorization(n)
 
    # Prthe prime count
    print("Distinct prime factor for first ", n, " natural number : ", end = "")
 
    for i in range(1, n + 1):
        print(len(adj[i]), end = " ")
 
# This code is contributed by mohit kumar 29


C#
using System;
using System.Collections.Generic;
public class GFG
{
  static int MAXN = 100001;
 
  // Stores smallest prime factor for every number
  static int[] spf = new int[MAXN];
 
  // Adjacency vector to store distinct prime factors
  static List> adj = new List>();
 
  // Calculating SPF (Smallest Prime Factor) for every
  // number till MAXN.
  // Time Complexity : O(nloglogn)
  static void sieve()
  {
    for(int i = 0; i < MAXN; i++)
    {
      adj.Add(new List());
    }
    spf[1] = 1;
 
    // marking smallest prime factor for every
    // number to be itself.
    for (int i = 2; i < MAXN; i++)
    {
      spf[i] = i;
    }
    for (int i = 2; i * i < MAXN; i++)
    {
 
      // checking if i is prime
      if (spf[i] == i)
      {
        // marking SPF for all numbers divisible by i
        for (int j = i * i; j < MAXN; j += i)
        {
 
          // marking spf[j] if it is not
          // previously marked
          if (spf[j] == j)
            spf[j] = i;
        }
      }
    }
  }
 
  // A O(nlog n) function returning distinct primefactorization
  // upto n natural number by dividing by smallest prime factor
  // at every step   
  static void getdistinctFactorization(int n)
  {
    int index, x, i;
    for(i = 1; i <= n; i++)
    {
      index = 1;
      x = i;
      if(x != 1)
      {
        adj[i].Add(spf[x]);
 
      }
      x = x / spf[x];
 
      // Push all distinct prime factor in adj
      while (x != 1)
      {
        if (adj[i][index-1] != spf[x])
        {
          adj[i].Add(spf[x]);
          index += 1;
        }
        x = x / spf[x];
      }
    }
  }
 
  // Driver code
  static public void Main ()
  {
 
    // Precalculating smallest prime factor
    sieve();    
    int n = 10;    
    getdistinctFactorization(n);
 
    // Print the prime count
    Console.Write("Distinct prime factor for first " +
                  n + " natural number" + " : ");
 
    for (int i = 1; i <= n; i++)
    {
      Console.Write(adj[i].Count + " ");
    }
  }
}
 
// This code is contributed by rag2127


输出
Distinct prime factor for first 10 natural number : 0 1 1 1 1 2 1 1 1 2 

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。