前言
听说大家都会了
Min_25
M
i
n
_
25
或州阁筛了,虚的一批的我马上学了一下。
Min_25筛
首先这种筛法可以用来筛某种积性函数的前缀和,当然也不一定要积性函数,某些特殊的函数也能筛,听说常数和空间都比州阁筛优秀,以绝对优势踩爆州阁筛,时间复杂度和州阁筛一样,也是
O(n34log(n√))
O
(
n
3
4
l
o
g
(
n
)
)
,当然本蒟蒻并不会证。
筛质数的函数值
现有一函数
F(x)
F
(
x
)
,求
举个例子,假设 F(x)=ik F ( x ) = i k ,那我们就是要求
现在用 Min_25 M i n _ 25 筛求上式的值,首先先求出 n−−√ n 内的所有质数并排好序, pi p i 表示第 i i 个质数,设一共有个质数。
再设
不难推出转移式
其中 g(pj−1,j−1) g ( p j − 1 , j − 1 ) 显然等于 ∑ji=1pki ∑ i = 1 j p i k
那我们要求的显然就为 g(n,v) g ( n , v ) ,我们可以发现,上述转移式都是由 g(?,j−1) g ( ? , j − 1 ) 转移到 g(?,j) g ( ? , j ) ,并且第一维可能的取值最多只有 n−−√ n 个,有时我们可以先预处理出第一维所有可能的取值,然后按照第二维分层算即可。
Code
//ask(n)=1^k+2^k+3^k+....+n^k
//quick(n)=n^k
//zh[n]=p[1]^k+p[2]^k+....+p[n]^k
#define fo(i,j,l) for(int i=j;i<=l;++i)
#define fd(i,j,l) for(int i=j;i>=l;--i)
ll l=1,r;
while(l<=n){
ll len=n/l; r=n/len;
if(len<=P)id1[len]=++m;else id2[r]=++m;
g[m]=ask(len)-1; w[m]=len;
//h[m]=len-1;
l=r+1;
}
fo(i,1,v)
fo(j,1,m)if((ll)p[i]*p[i]>w[j])break;
else{
int op=w[j]/p[i]<=P?id1[w[j]/p[i]]:id2[n/(w[j]/p[i])];
g[j]=g[j]-quick(p[i])*(g[op]-zh[i-1]);
//h[j]=h[j]-(h[op]-i+1);
}
同样的我们也能筛一个范围内质数的个数,代码中的
h
h
数组求解的即为质数个数。
积性函数求前缀和
求积性函数的前缀和有两种求法(某些非积性的特殊函数也可以),一个是递归版,一个是非递归版,各有各的长处。
现在对积性函数
F(x)
F
(
x
)
求前缀和,即求
∑ni=1F(i)
∑
i
=
1
n
F
(
i
)
。
递归版
设
于是我们可以很容易的得到
那所求值显然为 S(n,1)+F(1) S ( n , 1 ) + F ( 1 ) ,实现用递归。
Code
//zh[n]=F(p[1])+F(p[2])+.....+F(p[n])
//P=sqrt(n)
inline ll ask(ll x,int k)
{
if(x<=1||p[k]>x)return 0;
int wz=x<=P?id1[x]:id2[n/x];
ll ans=g[wz]-zh[k-1];
for(int i=k;i<=v&&(ll)p[i]*p[i]<=x;++i)
for(ll l=p[i],e=1;l*p[i]<=x;l=l*p[i],++e)
ans=ans+ask(x/l,i+1)*F(l)+F(p[i]*l);
return ans;
}
...
ans=ask(n,1)+F(1);
...
非递归版
方法和筛质数时的方法类似。
设
于是我们一样可以很容易的得到
那所求值显然为 S′(n,1)+F(1) S ′ ( n , 1 ) + F ( 1 ) ,关于实现一样先离散出第一维所有可能的取值,同时我们也能观察到转移都是从 S′(?,i+1) S ′ ( ? , i + 1 ) 转移到 S′(?,i) S ′ ( ? , i ) ,一样以第二维分层计算即可。
Code
//zh[n]=F(p[1])+F(p[2])+.....+F(p[n])
//P=sqrt(n)
//id1[],id2[]均为离散数组
#define fd(i,j,l) for(int i=j;i>=l;--i)
fd(i,u,1){
ll ww=ksm(p[i],k),U=(ll)p[i]*p[i];
fo(j,1,m)if(U<=w[j]){
for(ll o=p[i],u=w[j]/p[i];o*p[i]<=uu;o=o*p[i],u=u/p[i])
{
ok=(u<=P)?id1[u]:id2[n/u];
g[j]=g[j]+(g[ok]-zh[i])*F(o1);
g[j]=g[j]+F(o*p[i]);
}
}else break;
}
ans=g[1]+F(1);
关于两种版本的比较
首先如果仅是对一个
n
n
求解,那显然是第一个版本更快,因为它比第二个版本少遍历了很多无用状态。
但我们再看第二个版本,(设第一维所有可能的取值为),我们可以发现第二个版本中不仅求出了
S′(n,1)
S
′
(
n
,
1
)
,还求出了
S′(a1,1),S′(a2,1),......S′(au,1)
S
′
(
a
1
,
1
)
,
S
′
(
a
2
,
1
)
,
.
.
.
.
.
.
S
′
(
a
u
,
1
)
,而这是第一个版本做不到的,因此用哪个版本决定于题目。
事实证明当
n=109
n
=
10
9
时,第一个版本比第二个版本快
13
1
3
甚至快
12
1
2
。