線性篩質數

功能

輸出從0$0$到1000000$1000000$的所有質數。

思路

首先0$0$和1$1$不是質數，從2$2$開始逐個判斷是否為質數。如果t$t$為質數，那麼對於任意正整數k$k$，k×t$k\times t$不是質數，因此可以將k×t$k\times t$篩去。如果t$t$已經被篩去，那麼t$t$不是質數，但仍然要將k×t$k\times t$篩去。為了避免重複篩選，需要對篩選條件加以限制，當且僅當k$k$為k×t$k\times t$除了1$1$以外的最小因數時將k×t$k\times t$篩去，這樣可以保證每個數最多被篩選1$1$次。當k×t$k\times t$被篩去時，k$k$必然為質數，對於t$t$，如果t$t$為質數，那麼k$k$從2$2$到t$t$；如果t$t$為合數，那麼k$k$從2$2$到t$t$除了1$1$以外的最小因數。

時間複雜度

O(n)$O$

模板

#include <iostream>
using namespace std;
#include <cstring>

const int MAX = 1000000;

int pos;  // the amount of prime
int check[MAX];  // 0 to prime, 1 to composite
int prime[MAX];  // the prime numbers

/**
  * @other: 0 and 1 are not prime numbers
  */
void PRIME() {
  memset(check, 0, sizeof(check));
  pos = 0
 
;
  for (int i = 2; i < MAX; ++i) {
    if (check[i] == 0) prime[pos++] = i;
    for (int j = 0; j < pos; ++j) {
      if (prime[j]*i > MAX) break;  // check the numbers in the range
      check[prime[j]*i] = 1;
      if (i % prime[j] == 0) break;  // to avoid checking repeatly
    }
  }
}

擴充套件1

利用篩選得到的質數對n進行分解質因數。

模板1.1

#include "PRIME.h"

int count[MAX];  // the amount of prime numbers

/**
  * @param n: number N
  */
void EXT1(int n) {
  memset(count, 0, sizeof(count));
  for (int i = 0; n > 1; ++i) {
    while (n % prime[i] == 0) ++count[i];
  }
}

模板1.2

#include "EXT1.h"

int amount;  // the amount of prime factors
int factor[MAX];  // the prime factors

/**
  * @param n: number N
  */
void EXT2(int n) {
  amount = 0;
  for (int i = 0; prime[i]*prime[i] <= n; ++i) {
    while (n % prime[i] == 0) {
      factor[amount++] = prime[i];
      n /= prime[i];
    }
  }
  if (n > 1) factor[amount++] = n;
}

擴充套件2

計算n所有因數的和。設一共有k$k$種質因數，質因數ti$t_i$的數量為ai$a_i$，那麼因數和為∏ki=1∑aij=0tij$\prod _{i=1}^k\sum _{j=0}^{a_i}{t_i}^j$。

模板2

#include "EXT2.h"

/**
  * @param n: number N
  * @return: the sum of factors
  */
int EXT3(int n) {
  int ans = 1;  // the sum of factors
  for (int i = 0; i < pos; ++i) {
    int tmp = 1;  // the power of prime[i]
    int sum = 1;  // the sum of powers
    for (int j = 0; j < count[i]; ++j) {
      tmp *= prime[i];
      sum += tmp;
    }
    ans *= sum;
  }
  return ans;
}