Si pháp

Tố số si pháp

Dẫn vào

Nếu chúng ta muốn biết nhỏ hơn hoặc bằngCó bao nhiêu cái tố số đâu?

Một cái tự nhiên ý tưởng là đối với nhỏ hơn hoặc bằngMỗi cái số tiến hành một lần số nguyên tố kiểm nghiệm. Loại này bạo lực cách làm hiển nhiên không thể đạt tới tối ưu phức tạp độ.

Ai kéo Tost ni si pháp

Quá trình

Suy xét như vậy một việc: Đối với tùy ý một cái lớn hơnChính số nguyên,Như vậy nóLần chính là hợp số (). Lợi dụng cái này kết luận, chúng ta có thể tránh cho rất nhiều lần không cần thiết kiểm tra đo lường.

Nếu chúng ta từ nhỏ đến lớn suy xét mỗi cái số, sau đó đồng thời đem trước mặt cái này số sở hữu ( so với chính mình đại ) bội số nhớ vì hợp số, như vậy vận hành kết thúc thời điểm không có bị đánh dấu số chính là tố đếm.

Thực hiện

C++Python

vectorint>prime;
boolis_prime[N];

voidEratosthenes(intn){
is_prime[0]=is_prime[1]=false;
for(inti=2;in;++i)is_prime[i]=true;
for(inti=2;in;++i){
if(is_prime[i]){
prime.push_back(i);
if((longlong)i*i>n)continue;
for(intj=i*i;jn;j+=i)
// bởi vì từ 2 đến i - 1 bội số chúng ta phía trước si qua, nơi này trực tiếp từ i
// bội số bắt đầu, đề cao vận hành tốc độ
is_prime[j]=false;// là i bội số đều không phải tố số
}
}
}

prime=[]
is_prime=[False]*N


defEratosthenes(n):
is_prime[0]=is_prime[1]=False
foriinrange(2,n+1):
is_prime[i]=True
foriinrange(2,n+1):
ifis_prime[i]:
prime.append(i)
ifi*i>n:
continue
forjinrange(i*i,n+1,i):
is_prime[j]=False

Trở lên vìEratosthenes si pháp( ai kéo Tost ni si pháp, tên gọi tắt ai thị si pháp ), thời gian phức tạp độ là $O(n\log\log n)$ .

Chứng minh

Hiện tại chúng ta liền tới nhìn xem suy luận quá trình:

Nếu mỗi một lần đối số tổ thao tác tiêu phí 1 cái đơn vị thời gian, tắc thời gian phức tạp độ vì:

O\left(\sum_{k=1}^{\pi(n)}{\frac{n}{p_k}}\right)=O\left(n\sum_{k=1}^{\pi(n)}{\frac{1}{p_k}}\right)

Trong đóTỏ vẻ đệTiểu nhân tố số, $\pi(n)$ Tỏ vẻ $\le n$ Tố mấy cái số. $\sum_{k=1}^{\pi(n)}$ Tỏ vẻ tầng thứ nhất for tuần hoàn, trong đó mệt hơn nữa giới $\pi(n)$ Vìif (prime[i])Tiến vào true chi nhánh số lần; $\frac{n}{p_k}$ Tỏ vẻ tầng thứ hai for tuần hoàn chấp hành số lần.

Căn cứ Mertens đệ nhị định lý, tồn tại hằng sốKhiến cho:

\sum_{k=1}^{\pi(n)}{\frac{1}{p_k}}=\log\log n+B_1+O\left(\frac{1}{\log n}\right)

Cho nênEratosthenes si phápThời gian phức tạp độ vì $O(n\log\log n)$ .Kế tiếp chúng ta chứng minh Mertens đệ nhị định lý nhược hóa phiên bản $\sum_{k\le\pi(n)}1/p_k=O(\log\log n)$ :

Căn cứ $\pi(n)=\Theta(n/\log n)$ ,Cũng biết đệCái tố số lớn nhỏ vì $\Theta(n\log n)$ .Vì thế liền có

\begin{aligned} \sum_{k=1}^{\pi(n)}{\frac{1}{p_k}} &=O\left(\sum_{k=2}^{\pi(n)}{\frac{1}{k\log k}}\right) \\ &=O\left(\int_2^{\pi(n)}{\frac{\mathrm dx}{x\log x}}\right) \\ &=O(\log\log\pi(n))=O(\log\log n) \end{aligned}

Đương nhiên, mặt trên cách làm hiệu suất vẫn cứ không đủ hiệu suất cao, ứng dụng phía dưới vài loại phương pháp có thể hơi chút đề cao thuật toán chấp hành hiệu suất.

Si đến căn bậc hai

Hiển nhiên, muốn tìm được thẳng đếnMới thôi sở hữu tố số, chỉ đối không vượt qua $\sqrt n$ Tố số tiến hành sàng chọn liền đủ rồi.

C++Python

vectorint>prime;
boolis_prime[N];

voidEratosthenes(intn){
is_prime[0]=is_prime[1]=false;
for(inti=2;in;++i)is_prime[i]=true;
// i * i
for(inti=2;i*in;++i){
if(is_prime[i])
for(intj=i*i;jn;j+=i)is_prime[j]=false;
}
for(inti=2;in;++i)
if(is_prime[i])prime.push_back(i);
}

prime=[]
is_prime=[False]*N


defEratosthenes(n):
is_prime[0]=is_prime[1]=False
foriinrange(2,n+1):
is_prime[i]=True
# làm i tuần hoàn đến
foriinrange(2,isqrt(n)+1):# `isqrt` là Python 3.8 tân tăng hàm số
ifis_prime[i]:
forjinrange(i*i,n+1,i):
is_prime[j]=False
foriinrange(2,n+1):
ifis_prime[i]:
prime.append(i)

Loại này ưu hoá sẽ không ảnh hưởng tiến dần thời gian phức tạp độ, trên thực tế lặp lại trở lên chứng minh, chúng ta đem được đến $n \ln \ln \sqrt n + o(n)$ ,Căn cứ đối số tính chất, chúng nó tiến dần tương đồng, nhưng thao tác số lần sẽ rõ hiện giảm bớt.

Chỉ si số lẻ

Bởi vì trừ 2 bên ngoài số chẵn đều là hợp số, cho nên chúng ta có thể trực tiếp nhảy qua chúng nó, chỉ dùng quan tâm số lẻ liền hảo.

Đầu tiên, làm như vậy có thể làm chúng ta nội tồn nhu cầu giảm phân nửa; tiếp theo, sở cần thao tác ước chừng cũng giảm phân nửa.

Giảm bớt nội tồn chiếm dụng

Chúng ta chú ý tới sàng chọn khi chỉ cầnboolLoại hình số tổ.boolSố tổ một cái nguyên tố giống nhau chiếm dụngByte ( tứcSo đặc ), nhưng là tồn trữ một cái bố ngươi giá trị chỉ cầnCái so đặc liền đủ rồi.

Chúng ta có thể sử dụngVị giải toánTương quan tri thức, đem mỗi cái bố ngươi giá trị áp đến một cái so đặc vị trung, như vậy chúng ta chỉ cần sử dụngSo đặc ( tức $\dfrac n 8$ Byte ) mà phiByte, có thể lộ rõ giảm bớt nội tồn chiếm dụng. Phương thức này được xưng là “Vị cấp áp súc”.

Đáng giá nhắc tới chính là, tồn tại tự động chấp hành vị cấp áp súc số liệu kết cấu, như C++ trungvector&LTbool>Cùngbitset.

Mặt khác,vector&LTbool>CùngbitsetĐối trình tự có hằng số ưu hoá, thời gian phức tạp độ $O(n \log \log n)$ Ai thị si ở sử dụngbitsetHoặcvector&LTbool>Ưu hoá sau, tính năng thậm chí vượt qua thời gian phức tạp độÂu kéo si.

Tham kiếnbitset: Cùng ai thị si kết hợp.

Phân khối sàng chọn

Từ ưu hoá “Si đến căn bậc hai” cũng biết, không cần vẫn luôn giữ lại toàn bộis_prime[1...n]Số tổ. Vì tiến hành sàng chọn, chỉ giữ lại đến $\sqrt n$ Tố số liền đủ rồi, tứcprime[1...sqrt(n)].Cũng đem toàn bộ phạm vi phân thành khối, mỗi cái khối phân biệt tiến hành sàng chọn. Như vậy, chúng ta liền không cần đồng thời ở bên trong tồn người trung gian lưu nhiều khối, hơn nữa CPU có thể càng tốt mà xử lý hoãn tồn.

ThiếtLà một cái hằng số, nó quyết định khối lớn nhỏ, như vậy chúng ta liền có $\lceil {\frac n s} \rceil$ Cái khối, mà khối( $k = 0 \dots \lfloor {\frac n s} \rfloor$ ) bao hàm khu gianTrung con số. Chúng ta có thể theo thứ tự xử lý khối, nói cách khác, đối với mỗi cái khối,Chúng ta đem biến lịch sở hữu số nguyên tố ( từĐến $\sqrt n$ ) cũng sử dụng chúng nó tiến hành sàng chọn.

Đáng chú ý chính là, chúng ta ở xử lý cái thứ nhất con số khi yêu cầu hơi chút sửa chữa một chút sách lược: Đầu tiên, ứng giữ lại $[1, \sqrt n]$ Trung sở hữu số nguyên tố; đệ nhị, con sốCùngHẳn là đánh dấu vì phi tố số. Ở xử lý cuối cùng một cái khối khi, không nên quên cuối cùng một con sốCũng không nhất định ở vào khối cuối cùng.

Dưới thực hiện sử dụng khối sàng chọn tới tính toán nhỏ hơn hoặc bằngSố nguyên tố số lượng.

Thực hiện

intcount_primes(intn){
constexprstaticintS=10000;
vectorint>primes;
intnsqrt=sqrt(n);
vectorchar>is_prime(nsqrt+1,true);
for(inti=2;insqrt;i++){
if(is_prime[i]){
primes.push_back(i);
for(intj=i*i;jnsqrt;j+=i)is_prime[j]=false;
}
}
intresult=0;
vectorchar>block(S);
for(intk=0;k*Sn;k++){
fill(block.begin(),block.end(),true);
intstart=k*S;
for(intp:primes){
intstart_idx=(start+p-1)/p;
intj=max(start_idx,p)*p-start;
for(;jS;j+=p)block[j]=false;
}
if(k==0)block[0]=block[1]=false;
for(inti=0;iS&&start+in;i++){
if(block[i])result++;
}
}
returnresult;
}

Phân khối si pháp tiến dần thời gian phức tạp độ cùng ai thị si pháp là giống nhau ( trừ phi khối phi thường tiểu ), nhưng là sở cần nội tồn đem thu nhỏ lại vì $O(\sqrt{n} + S)$ ,Hơn nữa có càng tốt hoãn tồn kết quả. Về phương diện khác, đối với mỗi một đôi khối cùng khu gian $[1, \sqrt{n}]$ Trung tố số đều phải tiến hành phép chia, mà đối với nhỏ lại khối tới nói, loại tình huống này muốn không xong đến nhiều. Bởi vậy, ở lựa chọn hằng sốKhi muốn bảo trì cân bằng.

Khối lớn nhỏLấyĐếnChi gian, có thể đạt được tốt nhất tốc độ.

Tuyến tính si pháp

Ai thị si pháp vẫn có ưu hoá không gian, nó sẽ đem một cái hợp số lặp lại nhiều lần đánh dấu. Có biện pháp gì không bỏ bớt vô ý nghĩa bước đi đâu? Đáp án là khẳng định.

Nếu có thể làm mỗi cái hợp số đều chỉ bị đánh dấu một lần, như vậy thời gian phức tạp độ liền có thể hàng đến.

Thực hiện

C++Python

vectorint>pri;
boolnot_prime[N];

voidpre(intn){
for(inti=2;in;++i){
if(!not_prime[i]){
pri.push_back(i);
}
for(intpri_j:pri){
if(i*pri_j>n)break;
not_prime[i*pri_j]=true;
if(i%pri_j==0){
// i % pri_j == 0
// nói cách khác, i phía trước bị pri_j si qua
// bởi vì pri bên trong số nguyên tố là từ nhỏ đến lớn, cho nên i thừa thượng mặt khác số nguyên tố kết quả nhất định sẽ bị
// pri_j bội số si rớt, liền không cần ở chỗ này trước si một lần, cho nên nơi này trực tiếp break
// rớt thì tốt rồi
break;
}
}
}
}

pri=[]
not_prime=[False]*N


defpre(n):
foriinrange(2,n+1):
ifnotnot_prime[i]:
pri.append(i)
forpri_jinpri:
ifi*pri_j>n:
break
not_prime[i*pri_j]=True
ifi%pri_j==0:
"""
i % pri_j == 0
Nói cách khác, i phía trước bị pri_j si qua
Bởi vì pri bên trong số nguyên tố là từ nhỏ đến lớn, cho nên i thừa thượng mặt khác số nguyên tố kết quả nhất định sẽ bị
pri_j bội số si rớt, liền không cần ở chỗ này trước si một lần, cho nên nơi này trực tiếp break
Rớt thì tốt rồi
"""
break

Mặt trên loại nàyTuyến tính si phápCũng xưng làEuler si pháp( Âu kéo si pháp ).

Note

Chú ý tới si pháp cầu tố số đồng thời cũng được đến mỗi cái số nhỏ nhất chất ước số.

Si pháp cầu Âu kéo hàm số

Chú ý tới tại tuyến tính si trung, mỗi một cái hợp số đều là bị nhỏ nhất chất ước số si rớt. Tỷ như thiếtLàNhỏ nhất chất ước số, $n' = \frac{n}{p_1}$ ,Như vậy tuyến tính si trong quá trìnhThông qua $n' \times p_1$ Si rớt.

Quan sát tuyến tính si quá trình, chúng ta còn cần xử lý hai cái bộ phận, phía dưới đối $n' \bmod p_1$ Phân tình huống thảo luận.

Nếu $n' \bmod p_1 = 0$ ,Như vậyBao hàmSở hữu chất ước số.

\begin{aligned} \varphi(n) & = n \times \prod_{i = 1}^s{\frac{p_i - 1}{p_i}} \\\\ & = p_1 \times n' \times \prod_{i = 1}^s{\frac{p_i - 1}{p_i}} \\\\ & = p_1 \times \varphi(n') \end{aligned}

Kia nếu $n' \bmod p_1 \neq 0$ Đâu, lúc nàyCùngLà hơn kém nhau, căn cứ Âu kéo hàm số tính chất, chúng ta có:

\begin{aligned} \varphi(n) & = \varphi(p_1) \times \varphi(n') \\\\ & = (p_1 - 1) \times \varphi(n') \end{aligned}

Thực hiện

C++Python

vectorint>pri;
boolnot_prime[N];
intphi[N];

voidpre(intn){
phi[1]=1;
for(inti=2;in;i++){
if(!not_prime[i]){
pri.push_back(i);
phi[i]=i-1;
}
for(intpri_j:pri){
if(i*pri_j>n)break;
not_prime[i*pri_j]=true;
if(i%pri_j==0){
phi[i*pri_j]=phi[i]*pri_j;
break;
}
phi[i*pri_j]=phi[i]*phi[pri_j];
}
}
}

pri=[]
not_prime=[False]*N
phi=[0]*N


defpre(n):
phi[1]=1
foriinrange(2,n+1):
ifnotnot_prime[i]:
pri.append(i)
phi[i]=i-1
forpri_jinpri:
ifi*pri_j>n:
break
not_prime[i*pri_j]=True
ifi%pri_j==0:
phi[i*pri_j]=phi[i]*pri_j
break
phi[i*pri_j]=phi[i]*phi[pri_j]

Si pháp cầu Mobius hàm số

Định nghĩa

Căn cứ Mobius hàm số định nghĩa, thiếtLà một cái hợp số,LàNhỏ nhất chất ước số, $n'=\frac{n}{p_1}$ ,Có:

\mu(n)= \begin{cases} 0 & n' \bmod p_1 = 0\\\\ -\mu(n') & \text{otherwise} \end{cases}

NếuLà số nguyên tố, có $\mu(n)=-1$ .

Thực hiện

C++Python

vectorint>pri;
boolnot_prime[N];
intmu[N];

voidpre(intn){
mu[1]=1;
for(inti=2;in;++i){
if(!not_prime[i]){
mu[i]=-1;
pri.push_back(i);
}
for(intpri_j:pri){
if(i*pri_j>n)break;
not_prime[i*pri_j]=true;
if(i%pri_j==0){
mu[i*pri_j]=0;
break;
}
mu[i*pri_j]=-mu[i];
}
}
}

pri=[]
not_prime=[False]*N
mu=[0]*N


defpre(n):
mu[1]=1
foriinrange(2,n+1):
ifnotnot_prime[i]:
pri.append(i)
mu[i]=-1
forpri_jinpri:
ifi*pri_j>n:
break
not_prime[i*pri_j]=True
ifi%pri_j==0:
mu[i*pri_j]=0
break
mu[i*pri_j]=-mu[i]

Si pháp cầu số ước lượng cái số

DùngTỏ vẻSố ước lượng cái số,Tỏ vẻNhỏ nhất chất ước số xuất hiện số lần.

Số ước lượng cái số định lý

Định lý: Nếu $n=\prod_{i=1}^m p_i^{c_i}$ Tắc $d_i=\prod_{i=1}^m (c_i+1)$ .

Chứng minh: Chúng ta biết $p_i^{c_i}$ Số ước lượng có $p_i^0,p_i^1,\dots ,p_i^{c_i}$ CộngCái, căn cứ phép nhân nguyên lý,Số ước lượng cái số chính là $\prod_{i=1}^m (c_i+1)$ .

Thực hiện

Bởi vìLà tích tính hàm số, cho nên có thể sử dụng tuyến tính si.

Ở chỗ này đơn giản giới thiệu một chút tuyến tính si thực hiện nguyên lý.

ĐươngVì số nguyên tố khi, $\textit{num}_i \gets 1,\textit{d}_i \gets 2$ ,Đồng thời thiết $q = \left\lfloor \dfrac {i}{p} \right\rfloor$ ,Trong đóVìNhỏ nhất chất ước số.
ĐươngVìChất ước số khi, $\textit{num}_i \gets \textit{num}_q + 1,\textit{d}_i \gets \dfrac{\textit{d}_q}{\textit{num}_i} \times (\textit{num}_i + 1)$ .
ĐươngHơn kém nhau khi, $\textit{num}_i \gets 1,\textit{d}_i \gets \textit{d}_q \times (\textit{num}_i+1)$ .

C++Python

vectorint>pri;
boolnot_prime[N];
intd[N],num[N];

voidpre(intn){
d[1]=1;
for(inti=2;in;++i){
if(!not_prime[i]){
pri.push_back(i);
d[i]=2;
num[i]=1;
}
for(intpri_j:pri){
if(i*pri_j>n)break;
not_prime[i*pri_j]=true;
if(i%pri_j==0){
num[i*pri_j]=num[i]+1;
d[i*pri_j]=d[i]/num[i*pri_j]*(num[i*pri_j]+1);
break;
}
num[i*pri_j]=1;
d[i*pri_j]=d[i]*2;
}
}
}

pri=[]
not_prime=[False]*N
d=[0]*N
num=[0]*N


defpre(n):
d[1]=1
foriinrange(2,n+1):
ifnotnot_prime[i]:
pri.append(i)
d[i]=2
num[i]=1
forpri_jinpri:
ifi*pri_j>n:
break
not_prime[i*pri_j]=True
ifi%pri_j==0:
num[i*pri_j]=num[i]+1
d[i*pri_j]=d[i]//num[i*pri_j]*(num[i*pri_j]+1)
break
num[i*pri_j]=1
d[i*pri_j]=d[i]*2

Si pháp cầu số ước lượng cùng

Tỏ vẻSố ước lượng cùng,Tỏ vẻNhỏ nhất chất ước số $p^0+p^1+p^2+\dots p^k$ .

Thực hiện

C++Python

vectorint>pri;
boolnot_prime[N];
intg[N],f[N];

voidpre(intn){
g[1]=f[1]=1;
for(inti=2;in;++i){
if(!not_prime[i]){
pri.push_back(i);
g[i]=i+1;
f[i]=i+1;
}
for(intpri_j:pri){
if(i*pri_j>n)break;
not_prime[i*pri_j]=true;
if(i%pri_j==0){
g[i*pri_j]=g[i]*pri_j+1;
f[i*pri_j]=f[i]/g[i]*g[i*pri_j];
break;
}
f[i*pri_j]=f[i]*f[pri_j];
g[i*pri_j]=1+pri_j;
}
}
}

pri=[]
not_prime=[False]*N
f=[0]*N
g=[0]*N


defpre(n):
g[1]=f[1]=1
foriinrange(2,n+1):
ifnotnot_prime[i]:
pri.append(i)
g[i]=i+1
f[i]=i+1
forpri_jinpri:
ifi*pri_j>n:
break
not_prime[i*pri_j]=True
ifi%pri_j==0:
g[i*pri_j]=g[i]*pri_j+1
f[i*pri_j]=f[i]//g[i]*g[i*pri_j]
break
f[i*pri_j]=f[i]*f[pri_j]
g[i*pri_j]=1+pri_j

Giống nhau tích tính hàm số

Nếu một cáiTích tính hàm sốThỏa mãn: Đối với tùy ý số nguyên tốCùng chính số nguyên,Có thể ởThời gian nội tính toán,Như vậy có thể ởThời gian nội si ra $f(1),f(2),\dots,f(n)$ Giá trị.

Thiết hợp sốChất ước số phân giải là $\prod_{i=1}^k p_i^{\alpha_i}$ ,Trong đó $p_1<p_2<\dots<p_k$ Vì số nguyên tố, chúng ta tại tuyến tính si trung ký lục $g_n=p_1^{\alpha_1}$ ,NếuBị $x\cdot p$ Si rớt (Là số nguyên tố ), như vậyThỏa mãn như sau đệ đẩy thức:

g_n= \begin{cases} g_x\cdot p & x\bmod p=0\\\\ p & \text{otherwise} \end{cases}

Nếu,Thuyết minhChính là nào đó số nguyên tố thứ mịch, có thểTính toán;Nếu không, $f(n)=f(\frac{n}{g_n})\cdot f(g_n)$ .

Bổn tiết bộ phận nội dung dịch tự bác vănРешето ЭратосфенаCùng với tiếng Anh phiên dịch bảnSieve of Eratosthenes.Trong đó tiếng Nga bản bản quyền hiệp nghị vì Public Domain + Leave a Link; tiếng Anh bản bản quyền hiệp nghị vì CC-BY-SA 4.0.

Bổn giao diện gần nhất đổi mới:2024/10/9 22:38:42,Đổi mới lịch sử
Phát hiện sai lầm? Tưởng cùng nhau hoàn thiện?Ở GitHub thượng biên tập này trang!
Bổn giao diện cống hiến giả:iamtwz,StudyingFather,HeRaNO,Mr-Python-in-China,shuzhouliu,TravorLZH,weilycoder,wood3,YOYO-UIAT,1804040636,383494,aofall,CCXXXI,CoelacanthusHex,countercurrent-time,cubeheadsun,Early0v0,Enter-tainer,frank-xjh,gongyisheng,Great-designer,greyqz,H-J-Granger,hqztrue,ImpleLee,inkydragon,Ir1d,LJFYC007,luojiny1,Lutra-Fs,Marcythm,MegaOwIer,Menci,mgt,NachtgeistW,opsiff,partychicken,Peanut-Tang,PerfectPan,Persdre,shawlleyw,StableAgOH,Steaunk,SukkaW,sunruisjtu2020,TianKong-y,Tiphereth-A,TrisolarisHD,untitledunrevised,WAAutoMaton,WineChord,Xeonacid,YanWQ-monad,zhouyuyang2002
Bổn giao diện toàn bộ nội dung ởCC BY-SA 4.0CùngSATAHiệp nghị chi điều khoản hạ cung cấp, phụ gia điều khoản cũng khả năng ứng dụng