Processing math: 97%

狄利克雷卷积&莫比乌斯反演总结

狄利克雷卷积&莫比乌斯反演总结

Prepare

1、[P]表示当P为真时[P]1,否则为0

2、a|bba整除。

3、一些奇怪常见的函数:

1(n)=1

id(n)=n

σ(n)=n

d(n)=n

ϵ(n)=[n==1]

狄利克雷卷积

数论函数

数论函数指一类定义域是正整数,值域是一个数集的函数。

加法:逐项相加就可以辣(f+g)(x)=f(x)+g(x)

数乘:用一个常数乘(xf)(n)=xf(n)

狄利克雷卷积

定义两个数论函数的狄利克雷卷积

t=fg

t(n)=i|nf(i)g(ni)

等价于

t(n)=ij=nf(i)g(j)

狄利克雷卷积有以下性质(两个数论函数相等,是指两个函数的每一项都相等):

1、交换律fg=gf

2、结合律f(gh)=(fg)h

3、分配律fh+gh=(f+g)h

4、没有名字(xf)g=x(fg)

5、单位元ϵf=f,其中ϵ(n)=[n==1]

6、逆元:对于每一个f(1)0的函数f,都有fg=ϵ

讨论一下第六个结论,如何求一个函数的逆呢?

只需要定义

g(n)=1f(1)([n==1]i|n,i1f(i)g(ni))

这样的话

i|nf(i)g(ni)=f(1)g(n)+i|n,i1f(i)g(ni)=[n==1]

积性函数

如果一个数论函数f有当gcd(n,m)==1

f(nm)=f(n)f(m)

就称f为积性函数。

一些常见的积性函数:

ϵ(n)=[n==1],id(n)=n,idk(n)=nk

事实上他们也满足完全积性(即当gcd(n,m)1时,也有f(nm)=f(n)f(m))

特殊的,我们令id0(n)=1(n)=1

还有两个普通的积性函数

d(n)=nφ(n)=[1,n]n

还有两个重要结论:

两个积性函数的狄利克雷卷积是积性函数。

积性函数的逆是积性函数。

积性函数有什么用呢?

它可以线性筛

然而还有更有用的

莫比乌斯反演

一些理论

我们定义1的逆是μ

这样的话,如果g=f1,就有f=f1μ=gμ

换句话说,就是

g(n)=d|nf(d)f(n)=d|nμ(nd)g(d)

也可以这样子

g(d)=d|nf(n)f(d)=d|nμ(nd)g(n)

例子

怎么用呢?举几个例子(以下情况默认nm)


Eg1

ni=1mi=1[gcd(i,j)==1]

然后怎么办呢?

f(x)=ni=1mi=1[gcd(i,j)==x]g(x)=x|df(d)

f(1)=1|dμ(d1)g(d)f(1)=ni=1μ(i)g(i)

考虑g(x)是什么

g(x)=x|dni=1mi=1[gcd(i,j)==d]

g(x)=ni=1mi=1[x|gcd(i,j)]g(x)=nxi=1mxi=1[1|gcd(i,j)]g(x)=nxmx

带回f(1)

Ans=nx=1μ(x)nxmx

这个用整除分块可以做到O(n)


Eg2

ni=1mj=1gcd(i,j)

可化为

nd=1ni=1mj=1d[gcd(i,j)==d]nd=1dndi=1mdj=1[gcd(i,j)==1]

x=nd,y=md

nd=1dxi=1yj=1[gcd(i,j)==1]

套入我们刚才在Eg1求得的

nd=1dxi=1μ(i)xiyind=1dn/di=1μ(i)xidyid

化到现在是O(n)的,因为前后都可以数论分块

但是我们能做得更好

T=id

原式化为

nd=1dni=1μ(i)xTyTnT=1xTyTd|Tdμ(Td)

乍一看还是O(n)的呀,但是对于后面那一坨

f(T)=d|Tdμ(Td)f(T)=ij=Tid(i)μ(j)

两个积性函数相乘,可以线性筛呀!!

所以复杂度被我们压到了O(n)

updon2019.3.9:

发现以前没有讲线性筛,导致现在自己都不知道是怎么搞得了。。。

线性筛

我们筛μ的函数是长这样的(自动认为有模数):

int prime[MAX_N], mu[MAX_N]
bool nprime[MAX_N]; 
void sieve() { 
	mu[1] = 1;
	for (int i = 2; i <= N; i++) {
		if (!nprime[i]) prime[++tot] = i, mu[i] = Mod - 1; 
		for (int j = 1; i * prime[j] <= N; j++) { 
			nprime[i * prime[j]] = 1; 
			if (i % prime[j] == 0) break; 
			mu[i * prime[j]] = Mod - mu[i]; 
		} 
	} 
} 
C++

其实就是和筛素数的是一样的,

if (i % prime[j] == 0) break;

这句话保证了复杂度,因为你存的素数是递增的,

如果iprime[j]整除后,iprime[j+k](k>0)一定可以被prime[j]x的形式表示出来。

那么就有我们下面的一个问题:


Eg3

给定你一个数组f,求

ni=1mj=1f[gcd(i,j)]

其中n,m107,数据组数T104

由我们上面推的东西,将f看作一个数论函数,可以知道只要求出一个函数g=μf的前缀和,

这个问题就解决了。

一下是解决这个问题的几种方法(蒯的):

void get_g_1(int N, const int *f, int *g) {
  for (int i = 1; i <= N; i++) g[i] = 0;
  for (int i = 1; i <= N; i++)
    for (int j = 1; i * j <= N; j++)
      g[i * j] = (g[i * j] + mu[i] * f[j]) % mod;
} // 依照定义,O(nlogn)

void get_g_2(int N, const int *f, int *g) {
  for (int i = 1; i <= N; i++) g[i] = f[i];
  for (int i = 1; i <= N; i++)
    for (int j = 2; i * j <= N; j++)
      g[i * j] = (g[i * j] - g[i]) % mod;
} // 类似求狄利克雷卷积逆的方式,不需要线性筛 mu ,O(nlogn)

void get_g_3(int N, const int *f, int *g) {
  for (int i = 1; i <= N; i++) g[i] = f[i];
  for (int i = 0; i < prime_count; i++)
    for (int j = N / prime[i]; j >= 1; j--)
      g[j * prime[i]] = (g[j * prime[i]] - g[j]) % mod;
} // Magic! O(nloglogn)
C++

对于最后一种方法,理解成dp:

gi,n=d|n,diμ(d)f(n/d)

那么转移:

gi,n={gi1,npi

复杂度O(n\log\log n)


参考文章1

参考文章2

posted @   heyujun  阅读(4742)  评论(5编辑  收藏  举报
点击右上角即可分享
微信分享提示