数论学习总结（包会，含例题，未完成）

数论学习总结（未完成）

模版总结

快速幂

快速幂算法（Exponentiation by Squaring）是一种用于计算幂运算的高效算法。它通过将指数进行二进制拆分，并利用指数的二进制表示形式来减少乘法和幂运算的次数，从而提高计算速度。那么具体怎么做呢?

1. 将指数表示成二进制
2. 从右向左遍历二进制数，如果当前位为 $1$​，则将底数乘以自身的平方，否则只将底数平方
3. 每次计算完毕后，将指数右移一位（相当于除以 $2$）
4. 重复步骤 $2$ 和步骤 $3$，直到指数变为 $0$​。

代码实现：

long long qp(long long a, long long b,long long c)
{
	if(b==0) 
		return 1;
	if(b==1) 
		return a%c;
	long long t=qp(a,b/2,c)%c;
	return (((t*t)%c)*(b%2==0?1:a%c))%c;
}

质数

质数是什么呢？简而言之，就是只能被 $1$ 和他自己整除的正整数，其他正整数则为合数，但是呢？ $1$ 既不是质数，也不是合数，妥妥反骨。

试除法

那么这个呢就是判断一个数是否是质数的一个工具，时间复杂度是 $O(\log n)$。其实就是开根号遍历，如果除得尽就不是，如果都除不尽就是质数。

#include<bits/stdc++.h>
using namespace std;
bool is_prime(int x)  // 判定质数
{
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
}
int main()
{
    int x;
    cin>>x;
    if(is_prime(x))
    {
        cout<<"YES"<<endl;
    }
    else
    {
        cout<<"NO"<<endl;
    }
    return 0;
}

那我们针对判断质数的方法发出了质问，有没有更优的算法呢？你别说，有其实还是有的。我们根据一个定理：质数密度估计（质数定理）：$n$ 较大时，$\left[1,n\right]$ 中质数的数量接近为 $O(n÷\ln n)$。因此如果我们预处理 $\left[2,\lfloor \sqrt{n}\rfloor \right]$的质数表，每次用他们来试除，就可以做到 $O(\sqrt{n}÷\ln n)$。但是还有别的更快的方法，不过我太弱了，先不说了。

唯一分解定理

唯一分解定理其实就是 任何正整数 $n$ 都可以被分解成若干个质数的幂次相乘，简单表示成这样：${\prod }_i{p}_i^{c_i}$。

那么又有一个简单的性质，分解至多到 $O(\log n)$，因为至少至少全是 $2$。

gcd和lcm

int gcd(int a, int b)
{
	return b?gcd(b,a%b):a;
}

gcd表示两个数的最大公共因数，然后怎么求呢？可以使用stl库里面的__gcd或者是使用辗转相除法解决，下面会在exgcd之前提到。时间复杂度 $O(\log \max (n,m))$ 解决。然后 lcm 就是最小的公共倍数。然后我们不妨换一个角度去看 lcm 和 gcd。设 $n=\prod p_i^{c_i}，m=\prod p_i^{d_i}$。那么 $\gcd =\prod p_i^{\min (c_i,d_i)}，lcm=\prod p_i^{\max (c_i,d_i)}$。

所以我们得到一个非常简单的式子：$gcd\times lcm=n\times m$。

埃氏筛

相信有很多同学看到埃氏筛这个名字的时候都会以为是埃及人发明的，事实上这只是一个人的名字而已。那么他的思想是什么呢？也就是说先假定 $\ge 2$ 的数都是质数，从小到大考虑每一个 $i$ ，若是质数，则 $i$ 的倍数都不是质数，全部筛掉。时间复杂度 $O(n\ln \ln n)$​，代码如下：

const int maxn=2e6+6;
bool isprime[maxn];
void seive(){
    memset(isprime,true,sizeof(isprime));
    isprime[0]=isprime[1]=false;
    for(int i=2;i<=maxn-6;i++){
        if (isprime[i]) {
            for (int j = i * i; j <= maxn-6; j += i) {
                isprime[j] = false;
            }
        }
    }
}

欧拉筛/线性筛

欧拉筛是一种优秀的算法，他的复杂度是线形的，你可以这么认为就是在埃氏筛的基础上做了一个优化，也就是说 $6$ 这个合数，$2$ 会被筛一次，$3$ 也会被筛一次，那么在欧拉筛里面，记录一个数组，如果最小的质因子被筛掉了，那么剩下的不用筛了，肯定不是质数。

const int N = 1e8 + 3;
bool isprime[N];
int prime[N],cnt;
void ola(int n) {
	memset(isprime, true, sizeof(isprime));
	isprime[1] = 0;
 
	for (int i = 2; i <= n; i++) {
		if (isprime[i]) prime[++cnt] = i;//如果i没有被前面的数筛掉，则i是素数
 
		for (int j = 1; j<=cnt&&prime[j] <= n/i; j++) {//j枚举已经筛出的素数，该循环起到筛掉枚举素数的倍数的作用
			isprime[i * prime[j]] = 0;//把i*prime[j]筛掉
			if (i % prime[j] == 0) break;//保证不会重复筛
		}
	}
}

神秘的筛法

先问一个问题给大家：求出 $\left[l,r\right]$ 之间的所有素数，但是 $(l\le r\le 10^{12}，r-l\le 10^6)$。

很容易的就想到了欧拉筛或者埃氏筛，但是 $l$ 实在是太大了，根本无法使用他们，但是我们又注意到了 $r-l\le 10^6$。我们可以从这里作为突破口，再考虑到 $\le r$ 的合数必然有 $\le \sqrt{r}$ 的质因子，那我们先筛出来 $\left[1，\lfloor \sqrt{r}\rfloor \right]$ 的所有质数，再用这些质数去筛就可以了。只是复杂度比较恶习 $O(\sqrt{r}+(r-l)\log r)$ 或 $O(\sqrt{r}\ln \ln r+(r-l)\log r)$。

数论函数和积性函数

什么是数论函数的？也就是定义域为正整数的函数叫做数论函数。我们举几个接下来会很常用的函数，如欧拉函数 $\phi (n)$，莫比乌斯函数 $\mu (n)$，单位函数 $ϵ(n)$。那么这些都是什么意思呢？

• $\phi (n)$ 表示 $[1,n]$ 中与 $n$ 互质数的数的数量。读作
• $\mu (n)=\{\begin{array}{l}(-1{)}^k，n=p_1{p}_2\dots p_k，(p_i是质数)\\ 0，n的某个质因子的指数大于2\end{array}$，读作miu​
• $ϵ(n)$ 仅当 $n=1$ 时为 $1$，其他情况都是 $0$。读作epsilon。

那什么又是积性函数呢？若一个积性函数 $f$ 满足，对所有互质的 $n，m$，都满足 $f(nm)=f(n)f(m)$，则称 $f$ 是一个积性函数，上面的三个函数均是非常普通的积性函数。另外如果对所有的 $n，m$，都满足 $f(nm)=f(n)f(m)$，则称 $f$ 是一个完全积性函数，所有积性函数都可以用筛来简单地求解。

求欧拉函数

我们不妨用欧拉筛来求解，我们可以分类讨论。

• 当 $i$ 是质数时，显然 $\phi (i)=n-1$。
• 当 $i\not\equiv 0(\mathrm{mod}p)$ 时，$i$，$p$ 是互质的，故 $\phi (ip)=\phi (i)\phi (p)=(p-1)\phi (i)$
• 当 $i\equiv 0(\mathrm{mod}p)$ 时，$p$ 是 $i$ 的一个因子。

设 $i$ 的唯一分解中 $p$ 的指数是 $c$ ，因为 $\phi (p^c)=(p-1)p^{c-1}$，因此 $\phi (ip)=p\phi (i)$​。

代码如下：

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int a; 
	cin>>a;
	int res=a;
	for(int i=2;i<=a/i;i++)
	{
		if(a%i==0)
		{
			while(a%i==0)
				a/=i;
			res=res/i*(i-1);
		}
	}
	if(a>1)
		res=res/a*(a-1);
	cout<<res<<endl;
	return0;
}

求莫比乌斯函数

看起来这个名字非常的高大尚，事实上他和欧拉函数非常相似，甚至还要简单一些，我们依旧可以分类讨论。

• 当 $i$ 是质数时，显然 $\mu (i)=-1$。
• 当 $i\not\equiv 0(\mathrm{mod}p)$ 时，$i$，$p$ 是互质的，故 $\mu (ip)=\mu (i)\mu (p)=-\mu (i)$
• 当 $i\equiv 0(\mathrm{mod}p)$ 时，$p$ 是 $i$ 的一个因子，故 $\mu (ip)=0$。

代码如下：

int miu(long long x) 
{
	int sum=0;
	for(long long i=2;i<=x/i;i++)
	{
		int cnt=0;
		if(x%i==0)
		{		
			while(x%i==0)
			{
				cnt++;
				x/=i;
			}
			if(cnt>1)
				return 0;
			sum++;
		}
	}
	if(x!=1)
		sum++;
	return(sum&1)?-1:1;
}

函数的基本公式

欧拉函数和莫比乌斯函数与这么几个常见的公式，后面的例题可能会用到，大家一定要记住。

欧拉公式：记 $ n=\prod p_i^{c_i}$，则 $\phi (n)=\prod (p_i-1)p_i^{c_i-1}$。

那么他的用处是什么呢，就是快速计算一个 $\phi (n)$。

$\mu$ 的性质：${\sum }_{d|n}\mu (d)=\left[n=1\right]$。其中 $[n=1]$ 表示当 $n=1$ 时为1，否则为0。

数论分块

数论分块在后面的很多题目里都会用到，我们先来讲一下。数论分块可以快速计算一些含有除法向下取整的和式（即形如 ${\sum }_{i=1}^{n}f(i)g(\lfloor \frac{n}{i}\rfloor )$ 这样的和）。同时也可以在 $O(1)$ 的时间复杂度下计算 $f(r)-f(l)$ 或预处理出$f$ 的前缀和，数论分块就只需要话 $O(\sqrt{n})$ 的时间完成。其余的引理我们这里就不作介绍，有兴趣的同学自己去看就好了，其实是我太菜了，嘻嘻(#^.#)。最终的结论就是：

$\lfloor \frac{n}{i}\rfloor =\lfloor \frac{n}{j}\rfloor$

证明我们略微带一点：

首先令 $k=\lfloor \frac{n}{i}\rfloor$，我们就可以知道 $k\le \frac{n}{i}$

$\therefore \lfloor \frac{n}{k}\rfloor \ge \lfloor \frac{n}{\frac{n}{i}}\rfloor =\lfloor i\rfloor =i$

$\therefore j=\max 满足条件的所有i=i_{\max }=\lfloor \frac{n}{k}\rfloor =\lfloor \frac{n}{\lfloor \frac{n}{i}\rfloor }\rfloor$

现在知道了他是什么东西，那到底应该怎么去使用他呢？

首先我们先考虑和式，然后在使用数论分块加速，总之就是先求出 $f(i)$ 的前缀和，然后每次以 $\left[l,r\right]=\left[l,\lfloor \frac{n}{\lfloor \frac{n}{i}\rfloor }\rfloor \right]$ 为一块，分块求贡献相加即可。

下面这一块csdnlatex炸了，我把我写的截图给大家

同余

如果 $a\mathrm{mod}m=b\mathrm{mod}m$，那么称 $a,b$ 对模 $m$ 同余，写作：$a\equiv b(\mathrm{mod}m)$。
余数域 $0,1\dots p-1$ 被称作 $p$ 的剩余系。
接下来我们来讲一讲同余的一些结论。

1. $a\equiv b(\mathrm{mod}m)\iff m\mid (a-b)$
2. 若 $a\equiv b(\mathrm{mod}m)$ 且 $c]equivd(\mathrm{mod}m)$，那么 $a+c\equiv b+d(\mathrm{mod}m)$ 且 $a\times c\equiv b\times d(\mathrm{mod}m)$(可以加，减，乘，但是绝对不能除)
3. 若 $a\times c\equiv b\times c(\mathrm{mod}m)$，那么 $a\equiv b(\mathrm{mod}m(m,c))$，特别的，当 $\gcd (m,c)=1$ 时，$a\equiv b(\mathrm{mod}m)$。
4. 若 $a\equiv b(\mathrm{mod}m)$，那么对于 $m$ 的任意一个正因数 $n$，都有 $a\equiv b(\mathrm{mod}n)$。
5. 若 $a\equiv b(\mathrm{mod}m)$ 并且 $a\equiv b(\mathrm{mod}n)$，那么 $a\equiv b(\mathrm{mod}\left[m,n\right])$

费马小定理

这里我是真的不想打了，自己看看吧。

看过初等数论的同学就可以知道这里用的是二项式定理，当然归纳法也可以。

裴蜀定理

若 $a，b$ 是整数，且 $\gcd (a,b)$，那么对于任意整数 $x,y$ 一定是 $d$ 的倍数。特别地，一定存在 $ax+by=d$ 成立。

证明：

设 $ax+by$ 的最小正整数的值为 $r$，考虑 $a\mathrm{mod}r$，

设 $p=\lfloor \frac{a}{r}\rfloor$，则 $a\mathrm{mod}r=a-pr$

带入 $r$，得 $a\mathrm{mod}r=a-p(ax+by)$，

进一步得 $a(1-px)+b(-y)$，也是 $a{x}^{’}+b{y}^{’}$ 的形式。

而考虑到 $0\le a\mathrm{mod}r<r$，以及 $r$ 是 $ax+by$ 的最小整数值，

所以 $a\mathrm{mod}r=0$。即 $r$ 是 $a$ 的因数。

那么怎么求呢，那就不得不提到我们的 exgcd 了，它相比于费马小定理，不用考虑 $p$ 为质数的情况。代码如下：

int exgcd(int a,int b,int &x,int &y)
{
	if(b==0)
	{
		x=1;
		y=0;
		return a;
	}
	intg=exgcd(b,a%b,y,x);
	y-=a/b*x;
	return g;
}

然后这里的话只要求出一种解，求通解就非常简单了，所以我不多说了。然后这还可以求逆元（不会的往下滑），由裴蜀定理可知，若 $a$ 和 $p$ 互质，那么存在 $ax+py=1$，即 $ax\equiv 1(\mathrm{mod}m)$，这样子就可以求出 $\left[0,p\right)$ 之间 $a$ 在模 $p$ 意义下的逆元（即这个式子求出来的 $p$）。

逆元

如果关于 $x$ 的方程 $ax\equiv 1(\mathrm{mod}p)$的一个解为 $x_0$，那么就称 $x_0$ 是 $a$ 在模 $p$ 意义下的逆元，记作 $x_0=a^{-1}$，也记作 $x=inv(a)$。

但是逆元不一定存在，$a$ 再模 $p$ 意义下的逆元在的充要条件为 $\gcd (a,b)=1$​。

有了逆元，我们做除法的取模只要乘那个数的逆元就可以了，多么伟大的发明啊，QWQ。
求逆元的方法：

单个逆元：

• 快速幂（FM小定理）
• exgcd

预处理多个

• 线性筛
• 线性递推（公式，如下）

$$in{v}_i=(p-p÷i)\times in{v}_{p\%i}\%p$$

例题详解

毕业季

这是一道非常智慧的题目。

简化题意可得：从1~n中取k个数，使这k个数的最大公约数最大

因为两个数成倍数关系时，它们的最大公因数是两数中的较小数，也就是相对来说最大公因数较大。那么也就是说 $n÷k$ 。

#include<iostream>
#include<cstdio>
using namespace std;
long long n,k;
int main()
{
    cin>>n>>k;
    cout<<n/k;
    return 0;
}

因子个数和

令f(i)为i的因子个数，求f(1)+f(2)+…+f(n)的值

---

首先，我们肯定会想到 $O(n)$ 的方法，但是这一题的数据证明了这一题应该需要 $O(\sqrt{n})$。我知道我的同桌非常聪明，想到了一个神奇的方法，也就是一起算。所以代码长这样。

#include<bits/stdc++.h>
using namespaced std;
int main()
{
	long long n;
	cin>>n;
	long long ans=0;
	for(int i=1;i<=sqrt(n);i++)
	{
		ans+=((long long)i*i)/i*2+1;
	}
	cout<<ans<<endl;
	return 0;
}

但是我作为蒟蒻，想到了数论分块的模版题，然后写了出来，长这样：

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,k;
int solve2(int l,int r) 
{ 
	return r-l+1; 
}
int solve()
{
    int l=1,r=0,res=0;
	while(l<=n)
	{
		r=k/(k/l);
		res+=solve2(l,r)*(k/l);
		l=r+1;
	}
	return res;
}
signed main()
{
	scanf("%lld",&n);
	k=n;
	printf("%lld",solve());
}

我认为都还可以，所以都放出来了，大家自己比对。

完全平方数

一个数如果是另一个整数的完全平方，那么我们就称这个数为完全平方数，也称平方数。小A认为所有的平方数都是很perfect的~于是他给了小B一个任务：用任意个不大于n的不同的正整数相乘得到完全平方数，并且小A希望这个平方数越大越好。请你帮助小B告诉小A满足题意的最大的完全平方数。

---

首先我们要知道一个性质：对于一个完全平方数，其分解质因数后每个质因数的次幂为偶数，所以我们将 $1$ 到 $n$ 的数分解质因数后，将质因数个数为奇数的 $-1$(相当于去掉了若干个互不相同的质数)。然后就可以得到一个最大的完全平方数。
因为将每个数质因数分解的复杂度比较大，所以我们从质数开刀，记录有多少个数包含他，显然 $1-n$ 中有 $n÷prim{e}_j$ 个数有 $prim{e}_j$ 这个质数，包含 $2$ 次的为 $n÷prim{e}_j÷prim{e}_j$ 个。这个可以用肥肠煎蛋的分配律来考虑。接下来放上代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5000007;
const int pyz=1e8+7;
int n,m;
inline int read()
{
    char c;
    int res,flag=0;
    while((c=getchar())>'9'||c<'0') if(c=='-')flag=1;
    res=c-'0';
    while((c=getchar())>='0'&&c<='9') res=(res<<3)+(res<<1)+c-'0';
    return flag?-res:res;
}
bool is[N];
int ans,tmp,cnt[N],prime[N];
inline int ksm(int s,int t)
{
    int res=1;
    while(t)
    {
        if(t&1) res=(ll)res*s%pyz;
        s=(ll)s*s%pyz;
        t>>=1;
    }
    return res;
}
int main()
{
    n=read();
    for(int i=2;i<=n;++i)
    {
        if(!is[i]) prime[++prime[0]]=i;
        for(int j=1;j<=prime[0]&&i*prime[j]<=n;++j)
        {
            is[i*prime[j]]=1;
            if(!(i%prime[j])) 
				break;
        }
    }
    for(int i=1;i<=prime[0];++i)
    {
        tmp=n;
        while(tmp/prime[i]>0)
        {
            cnt[i]+=tmp/prime[i];
            tmp/=prime[i];
        }
    }
    ans=1;
    for(int i=1;i<=prime[0];++i)
    {
        if(cnt[i]&1) cnt[i]--;
		ans=(ll)ans*ksm(prime[i],cnt[i])%pyz;
    }
    printf("%d",ans);
}

寒风农场

这道题目的难点就在于读题目，我们不妨来简化一下题面，$a+(a\mathrm{mod}n)+((a+(a\mathrm{mod}n))\mathrm{mod}n)+\dots$ 什么时候是 $n$ 的倍数，我们再化简一下 $(a+(a\mathrm{mod}n)+((a+(a\mathrm{mod}n))\mathrm{mod}n)+\dots )\mathrm{mod}n$ 这个式子什么时候等于 $0$ 。再再化简一下，可以得到 $(a+a^2+a^4+a^8+\dots )\mathrm{mod}n$ 这个式子什么时候等于 $0$ 。接下来就是皆大欢喜的暴力了。

#include<bits/stdc++.h>
#define int long long
using namespace std;
int T,a,n;
bool check(int x)
{
	int k=1;
	if(x==0)
		return false;
	while(k<=x)
	{
		if(k==x)
			return true;
		k*=2;
	}
	return false;
}
signed main()
{
	cin>>T;
	for(int i=1;i<=T;i++)
	{
		scanf("%lld%lld",&a,&n);
		bool flag=true;
		for(int j=1;j<=30;j++)
		{
			if(a%n==0)
			{
				cout<<"Yes"<<endl;
				flag=false;
				break;
			}
			a*=2;
		}
		if(flag)
			cout<<"No"<<endl;
	}
}

CQOI余数之和

首先，简化题意是必不可少的，那么这一题求的就是 $ans={\sum }_{i=1}^{n}k\%i$。那么搞清楚这一点之后，我们又知道高精取模也就是 $a\mathrm{mod}b=a-b\times \lfloor \frac{a}{b}\rfloor$，所以 $ans={\sum }_{i=1}^{n}k-i\times \lfloor \frac{k}{i}\rfloor =nk-{\sum }_{i=1}^{n}i\times \lfloor \frac{k}{i}\rfloor$。根据模数据，我们可以知道，这道题又要用到数论分块了，所以我们从 $\lfloor \frac{k}{i}\rfloor$ 出发做分块，$\lfloor \frac{k}{i}\rfloor$ 大约有 $\sqrt{k}$ 种取值所以时间复杂度 $O(\sqrt{k})$。上代码：

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,k;
int solve2(int l,int r) 
{ 
	return((l+r)*(r-l+1))>>1; 
}
int solve() 
{
    int l=1,r=0,res=0;
    while(l<=n) 
	{
        if(k/l) 
			r=min(n,k/(k/l)); 
		else 
			r=n;
        res+=solve2(l,r)*(k/l);
        l=r+1;
    }
    return res;
}
signed main() 
{
    cin>>n>>k;
    cout<<(n*k-solve())<<endl;
}

5的倍数的个数

一个长度为 $n$ 的数字串 $s$，有多少种方法可以使得删除若干个数字后剩下的数字串构成的数字能被 $5$​ 整除。可以有前导零，但删完后的数字串不能为空。

---

这道题我们需要先考虑单独一个串的情况，假设第 $i$ 位上的数字为 $0$ 或者是 $5$ ，就说明了只要把 $\left[i+1,n\right]$ 全部删掉就满足条件了。$\left[1,i+1\right]$ 这段里面的数非常随意，每一个会对答案产生 $2^{i-1}$ 的贡献。然后再考虑 $k$ 个 $s$ 的情况，假设单独一个串 $s$ 对答案的总贡献为 $ans$ ，则 $ss$ 就会对答案产生 $ans+2n\times ans$ 的贡献，其中 $n$ 表示 $s$ 的长度，相当于把第一个 $s$ 中的每个数字都删或不删，总共就是 $2n$ 次方种情况，再用乘法原理乘上第二个 $s$ 中的情况，然后我们就得到了一个漂亮的等比数列，然后求和，用上快速幂，FM小定理求一下逆元就完成了，上代码：

#include<bits/stdc++.h>
using namespace std;
const int mod=1000000007;
#define int long long 
long long qp(long long a, long long b,long long c)
{
	if(b==0) 
		return 1;
	if(b==1) 
		return a%c;
	long long t=qp(a,b/2,c)%c;
	return (((t*t)%c)*(b%2==0?1:a%c))%c;
}
signed main(){
    string s;
    int ans=0;
    int n,k;
    cin>>s;
    scanf("%lld",&k);
    n=s.size();
    for(int i=0;i<n;i++)
	{
        if(s[i]-'0'==0||s[i]-'0'==5)
		{
            int a=i;
            int fenzi=(qp(2,k*n+a,mod)-qp(2,a,mod)+mod)%mod;
            int fenmu=qp((qp(2,n,mod)-1+mod)%mod,mod-2,mod);
            ans+=fenzi*fenmu%mod;
        }
    }
    printf("%lld\n",ans%mod);
    return 0;
}