NOIP数学知识

数学知识

质数

1.质数分布定理：在$1\sim N$中大约有$\frac{x}{\ln x}$个，N越大越精准

2.判断n为质数的方法:试除法：(可以顺带求出约数集合)

int t=sqrt(n);
if(n<2)return false;
for(int i=2;i<=t;i++){
   
    if(n%i==0)return false;
}
return true;

3.欧拉筛(线性筛质数)：

int v[MAX_N],prime[MAX_N];
void primes(int n){
   
    memset(v,0,sizeof v); 
    int cnt=0;//质数数量 
    for(int i=2;i<=n;i++){
   
        if(!v[i]){
   
            v[i]=i,prime[++cnt]=i;
        } 
        for(int j=1;j<=cnt;j++){
   
            if(prime[j]>v[i]||prime[j]*i>n)
                break;
            v[i*prime[j]]=prime[j];

        }
    }
    for(int i=1;i<=cnt;i++)printf("%d ",prime[i]);
}

4.$N!$中质数p的个数为：

$$\sum _{p^k\le N}\lfloor \frac{N}{p^k}\rfloor$$

约数

1.设$N$被算术基本定理分解为$N=p_1^{c_1}{p}_2^{c_2}{p}_3^{c_3}\dots p_m^{c_m}$

则$N$的正约数个数为：

$$(c_1+1)\ast (c_2+1)\ast \dots (c_m)+1=\prod _{i=1}^m(c_i+1)$$

和为:

$$\prod _{i=1}^m\left(\sum _{k=0}^{c_i}(p_i{)}^k)\right)=\prod _{i=1}^m\left(\frac{p_i^{c_i+1}-1}{p_i-1}\right)$$

2.求$1\sim N$中每个数的正约数集合：倍数法

vector<int>factor[MAX_N];
for(int i=1;i<=n;i++){
	for(int j=1;j<=n/i;j++){
		factor[i*j].push_back(i);
	}
}

时间复杂度为$\Theta (N\log N)$

推论：$1\sim N$中每个数的约数个数约为$N\log N$1

gcd

定理

$\forall a,b\in \mathbb{N}$    ,  $\operatorname{lcm}(x,y)=\frac{x \times y}{\gcd(x,y)} $

$\forall a,b\in \mathbb{N}$   , $\gcd (a,b)=\gcd (b,a\mathrm{mod}b)$

exgcd:

解决：求：$ax+by=gcd(a,b)$的一组解：

code:

void exgcd(int a,int b,int&x,int &y){
	if(!b){
		x=0,y=1;
		return a;
	}
	int d=exgcd(b,a%b,x,y);
	int z=x;
	x=y,y=z-(a/b)*y;
	return d;
}

欧拉函数 $\phi$

定义：$1\sim N$中与$N$互质的数的个数是关于$N$的欧拉函数，记作$\phi (N)$

求法：

$$\phi (N)=\prod _{\text{质数}p|N}\left(\frac{p-1}{p}\right)$$

性质:

1.$1\sim n$中与$n$互质的数的和为：$n\ast \frac{\phi (n)}{2}$

2.若$\gcd (a,b)=1$，则$\phi (ab)=\phi (a)\phi (b)$

3.在算术基本定理中$n={\prod }_{i=1}^m(p_i^{c_i})$,则$\phi (n)={\prod }_{k=1}^m\phi (p_i^{c_i})$， 此性质所有积性函数都具备

4.若$p$为质数且$p|n,p^2|n$,则$\phi (n)=\phi (\frac{n}{p})p$

5.若$p$为质数且$p|n,p^2\nmid n$,则$\phi (n)=\phi (\frac{n}{p})(p-1)$
6.${\sum }_{d|n}\phi (d)=n$

欧拉函数的递推求解：

由性质4，5，我们可以在求质数的时候顺带求出欧拉函数

int v[MAX_N],prime[MAX_N],phi[MAX_N];
void euler(int n){  
    memset(v,0,sizeof v);
    int cnt=0;
    for(int i=2;i<=n;i++){  
        if(!v[i]){  
            v[i]=i;
            prime[++cnt]=i;
            phi[i]=i-1;        
        }
        for(int j=1;j<=cnt;j++){  
            if(prime[j]>v[i]||i*prime[j]>n)break;
            v[i*prime[j]]=prime[j];
            phi[i*prime[j]]=phi[i]*(i%prime[j]?prime[j]-1:prime[j]);
        }
    }
}

同余

1.欧拉定理

$$\text{若正整数a,n互质，则}{a}^{\phi (n)}\equiv 1(\mathrm{mod}n)$$
推论：

$$\text{若正整数a,n互质，则}{a}^b\equiv a^{b\mathrm{mod}\phi (n)}(\mathrm{mod}n)$$
当a,n不一定互质的时候有(扩展欧拉定理)：

$$a^b\equiv a^{b\mathrm{mod}\phi (n)+\phi (n)}(\mathrm{mod}n)$$

2.裴蜀定理： 对于任意整数a,b，存在一对整数x,y满足：$ax+by=\gcd (a,b)$

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

对于更加一般的一次不定方程$ax+by=c$，设$d=\gcd (a,b)$，它有解当且仅当$d|c$
我们可以先用$\mathrm{exgcd}$求出方程$ax+by=d$的一组解$x_0,y_0$,这样方程$ax+by=c$的解$x=x_0\times \frac{c}{d}$,y同理
由此我们可以设方程$ax+by=c$的一组解为$x_0,y_0$，则它的所有整数解为：

$$x=x_0+k\frac{b}{d},y=y_0+k\frac{a}{d},k\in \mathbb{Z}$$

乘法逆元

定义，设$bd\equiv 1(\mathrm{mod}n)$,则b为d关于模n的乘法逆元，d为b关于模n的乘法逆元

求法：1.若n是质数，则$d=b^{n-2}$

2.若仅仅是保证b,n互质，则d可通过求解线性同余方程求得

解线性同余方程

对于线性同余方程$ax\equiv b(\mathrm{mod}m)$，可以将其看作$ax+bm=b$的不定方程来解，这里的$x$就是线性同余方程的解

中国剩余定理

设$m_1,m_2,m_3\dots \dots \dots m_n$是两两互质的整数，设$M={\prod }_{i=1}^n{m}_i,M_i=\frac{M}{m_i}$,设$t_i$是线性同余方程$M_i{t}_i\equiv 1(\mathrm{mod}{m}_i)$的一个解
则对于同余方程组：

$$\{\begin{array}{rl}x& \equiv a_1(\mathrm{mod}{m}_1)\\ x& \equiv a_2(\mathrm{mod}{m}_2)\\ x& \equiv a_3(\mathrm{mod}{m}_3)\\ & \dots \\ x& \equiv a_n(\mathrm{mod}{m}_n)\end{array}$$
有解，解为：

$$x=\sum _{i=1}^n{a}_i{M}_i{t}_i+km,k\in \mathbb{Z}$$

扩展中国剩余定理(excrt)

特别的，当$m_1\sim m_n$并不两两互质的时候
假设我们已经求出了前$k-1$个方程的通解，记$m=\mathrm{lcm}(m_1\sim m_{k-1})$，则$x+im,i\in \mathbb{Z}$是方程的通解，此时我们需要求出一个$t$使得$x+tm\equiv a_k(\mathrm{mod}{m}_k)$,此时$x+tm$就是前k个方程的解,所以其实我们可以将excrt理解为n次exgcd

高次同余方程：$a^x\equiv b(\mathrm{mod}p)$

拔山盖世(大步小步：Baby Step,Giant Step)算法

前提：a,p互质

因为a,p互质，所以可以在模p的意义下进行关于a的乘除运算
设$x=i\times t-j,t=\lfloor \sqrt{p}\rfloor ,i\in [0,t],j\in [0,t-1]$
则方程式子可变为：$(a^t{)}^i\equiv a^j\times b(\mathrm{mod}p)$,此时枚举$j$的取值，将$a_j\times b$插入一个$\mathrm{Hash}$表中，然后再枚举$i$在表中查找即可

int BSGS(int a,int b,int p){
	int t=sqrt(p)+1;b%=p,a%=p;
	map<int,int>hash;hash.clear();
	for(int i=0;i<t;i++){
		hash[power(a,i,p)*b%p]=i;
	}
	a=power(a,t,p);
	if(!a)return b==0?1:-1; 
	for(int i=0;i<=t;i++){
		int m=power(a,i,p);
		int j=hash.find(m)==hash.end()?-1:hash[m];
		if(j>=0&&i*t-j>=0){
			return i*t-j;
		}
	}
	return -1;
} 

exBSGS

$Code$
:

int gcd(int a,int b){return !b?a:gcd(b,a%b);}
int exgcd(int a,int b,int &x,int &y)
{
	if(!b)
	{
		x=1,y=0;
		return a;
	}
	int gcd=exgcd(b,a%b,y,x);
	y-=(a/b)*x;
	return gcd;
}
inline int exBSGS(int a,int b,int mod)
{
	b%=mod;
	if(b==1||mod==1)	return 0;
	int g=0,val=1;
	while(true)
	{
		int d=gcd(a,mod);
		if(d==1)	break;
		if(b%d)	return -1;
		b/=d,mod/=d,val=val*a/d%mod;
		g++;
		if(b==val)	return g;
	}
	int x,y;
	exgcd(val,mod,x,y);
	x=(x%mod+mod)%mod;
	b=b*x%mod,a%=mod;
	map<int,int>mp;
	int t=ceil(sqrt(mod));
	int z=1;
	for(int i=0;i<t;i++)
		mp[b*z%mod]=i,z=z*a%mod;
	int p=1;
	for(int i=1;i<=t;i++)
	{
		p=p*z%mod;
		if(mp.count(p))	return i*t-mp[p]+g;
	}
	return -1;
}
signed main()
{
	a=read(),p=read(),b=read();
	while(a||b||p)
	{
		int ans=exBSGS(a,b,p);
		if(ans==-1)	puts("No Solution");
		else	printf("%lld\n",ans);
		a=read(),p=read(),b=read();
	}
	return 0;
}

矩阵乘法

定义，设A是$m\times n$矩阵，B是$n\times p$矩阵，则$C=A\times B$是一个$m\times p$矩阵

性质：
$A\times B$不一定等于$B\times A$,

$(A\times B)\times C=A\times (B\times C)$,

$(A+B)\times C=A\times C+B\times C$

定义，设$C=A\times B$,A是$m\times n$矩阵，B是$n\times p$矩阵,

$$C_{i,j}=\sum _{1\le k\le n}\left(A_{i,k}\ast B_{k,j}\right)\text{，其中}(1\le i\le m,1\le j\le p)$$

for(int i=1;i<=m;i++)
    for(int j=1;j<=p;j++)
        for(int k=1;k<=n;k++)
            c[i][j]+=a[i][k]*b[k][j];

考虑一种特殊情形，矩阵$F\times Q$,其中Q是$n\times n$矩阵，F是$1\times n$矩阵
若是设$F^{\prime }=F\times Q$,则$F^{\prime }[i]=$