数学知识(数论三)

最新推荐文章于 2022-04-27 11:32:13 发布
最新推荐文章于 2022-04-27 11:32:13 发布
阅读量678 收藏
点赞数
分类专栏： 算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41320429/article/details/103378078
版权

文章目录

数论（三）

高斯消元

即用线性代数的方式解决n元一次方程组
思路：
将n元一次方程组转化为上三角形的形式
基本操作（不影响结果）：

  • 把某一行乘以一个非零的数
  • 交换某两行
  • 把某一行的若干倍加到另一行上去

步骤：

  1. 定义行r=0列c=0,系数矩阵a[N][N]
  2. 从第r行c列开始整理这个方程组
  3. 找到第c列的最大值(绝对值)所在的行t，如果第c列的最大值是0，则说明出现了无用约束等式(矩阵的秩r<行列式的个数n)，进行下一次循环continue
  4. 将第t行的数与第r行交换
  5. 将第r行的第c列变为1，也就是第r行同除以a[r][c]
  6. 将第r行之后的所有行的第c列变为0，也就是r+1~n行应该减去其第c列元素的值
  7. r++，c++，重复步骤

结果：

  • 如果r<n (约束条件小于n)，说明无解或者无穷多解，此时再分类讨论，如果出现等式0=!0则无解，否则说明无用约束全部是0=0，那么有无穷多解
  • r=n有唯一解 ，此时处理系数矩阵成答案的形式

在这里插入图片描述
在这里插入图片描述

883高斯消元解线性方程组

在这里插入图片描述

#include<iostream>
#include<algorithm>
#include<cmath>

using namespace std;

const double eps=1e-6;

const int N=110;

int n;

double a[N][N];        //系数数组

int gauss(){
    
    int r,c;        //定义行列,r同时也代表矩阵的秩
    
    for(r=0,c=0;c<n;c++){       //从0行0列开始枚举，如果某一列全部为0，r不会++，(线性代数中相当于有一行式子无效)   ,注意此处c<n而不是c<=n,不枚举常数列
        
        //找当前列数值最大的那一行
        int t=r;
        
        for(int i=t+1;i<n;i++)
        
            if(fabs(a[i][c])>fabs(a[t][c]))t=i; //系数有可能有负数，使用绝对值比较大小
        
        if(fabs(a[t][c])<eps)continue;     //如果最大值是0,说明出现无用约束等式，跳过
        
        
        //把找到的那一行移动到第r行（相对不动行的最顶行）,c列之前列的数值都是0,不需要再交换
        for(int i=c;i<=n;i++)swap(a[r][i],a[t][i]);
        
        //把第r行第一个数处理成1，从后往前处理否则a[r][c]会发生变化
        for(int i=n;i>=c;i--)a[r][i]/=a[r][c];
        
        
        //把r+1到n行全部减掉相应倍数，使每行第c个数是0
        for(int i=r+1;i<n;i++)
           for(int j=n;j>=c;j--)a[i][j]-=a[r][j]*a[i][c];           //这一步也是从后往前处理，不需要除以a[r][c]因为a[r][c]已经是1
        
        
        r++;     //如果continue,r不加，r也代表有用的约束等式
        
    }
    
    
    //如果约束等式小于n只可能是无解或者无穷多解
    if(r<n){
        
        for(int i=r;i<n;i++)if(fabs(a[i][n])>eps)return 2;   //如果存在一个(可能有多个)无效约束等式的b不为0，说明无解
        
        return 1;
        
    }
 
    //有解，处理系数矩阵，每一行的最后一个元素由下一行的最后一个元素对应位置的倍数相消
   for(int i=n-2;i>=0;i--)
    
        for(int j=i+1;j<n;j++)
        
        a[i][n]-=a[j][n]*a[i][j];
        
    return 0;
        
     
    
}


int main(){

    cin>>n;
    
    for(int i=0;i<n;i++)
        for(int j=0;j<=n;j++)
        cin>>a[i][j];
        
    int t=gauss();    

    if(t==0){
        
        for(int i=0;i<n;i++)printf("%.2lf\n",a[i][n]);
        
    }
    
    if(t==1)cout<<"Infinite group solutions";
    
    if(t==2)cout<<"No solution";
    
    return 0;
}

884高斯消元解异或线性方程组

在这里插入图片描述

思路：

  • 与高斯消元的思路一致，将异或线性方程组转换成上三角的形式
  • 根据矩阵的秩判断是否有解
  • 与高斯消元不同的是，要将某一行的系数削成0，只需要使用异或操作即可

步骤：

  1. 定义行列r,c按列枚举
  2. 找到当前列不为0的一行，将它交换到第一行
  3. 将除了这一行以外的其余所有行的当前列削成0(异或)
  4. 重复步骤
  5. 根据矩阵的秩枚举结果
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int N=110;

int a[N][N];

int n;

int gauss(){
    int r,c;
    
    for(r=0,c=0;c<n;c++){
        int t=r;
        
        for(int i=r;i<n;i++)      //找到不为0的一行
            if(a[i][c]){
                t=i;
                
                break;
            }
        
        if(!a[t][c])continue;      //如果该列全部为0，则出现秩小于n的情况
        
        if(t!=r){
            for(int i=c;i<=n;i++)swap(a[t][i],a[r][i]);
        }
        
        for(int i=r+1;i<n;i++){
            if(a[i][c])for(int j=c;j<=n;j++)a[i][j]^=a[r][j];  //将该列其余 首元素不为0的行清0
        }
        
        r++;
        
    }
    
    if(r<n){
        for(int i=r;i<n;i++)if(a[i][n])return 0;              //讨论秩小于n的情况
        
        else return 1;
    }
    
    else{
        for(int i=n-1;i>=1;i--){
            for(int j=i-1;j>=0;j--)a[j][n]^=a[j][i]*a[i][n];   //按列相消，和上面略有区别
        }
        
        
        return 2;
    }
    
}

int main(){
    cin>>n;
    
    for(int i=0;i<n;i++)
        for(int j=0;j<=n;j++)cin>>a[i][j];     
        
    int t=gauss();
    
    if(t==0)cout<<"No solution";
    
    else if(t==1)cout<<"Multiple sets of solutions";
    
    else {
        for(int i=0;i<n;i++){
            cout<<a[i][n]<<endl;
        }
    }
}

组合数

在这里插入图片描述

  • 性质：
    C ( n m ) = C ( n m − 1 ) + C ( n − 1 m − 1 ) C\tbinom{n}{m}=C\tbinom{n}{m-1}+C\tbinom{n-1}{m-1} C(mn​)=C(m−1n​)+C(m−1n−1​)

以下四道题目分别代表求组合数的四种方式 时间复杂度对应每一次询问的时间复杂度，由于是提前预处理，询问的时间复杂度应当和与处理的复杂度相加

  1. 10^5次询问 ，二维矩阵预处理 1<=b<=a<=2000 O ( n 2 ) O(n^2) O(n2) n=2000
  2. 10^4次询问，快速幂预处理 1<=b<=a<=10^5 O ( N l o g ( M o d ) ) O(Nlog(Mod)) O(Nlog(Mod)) Mod=1e9 +7
  3. 20次 询问 ，卢卡斯定理预处理 1<=b<=a<=10^18 O ( l o g P N ∗ l o g P ) O(log_{P}N*log{P}) O(logP​N∗logP)约等于 O ( P l o g P ) O(PlogP) O(PlogP) Mod=P=1e5
  4. 1次询问 ，分解质因数+高精度 1<=b<=a<=5000 O O O

885求组合数I（n2）

方式一：直接预处理出0~2000的所有组合数（对），将他们存到二维数组中，直接通过查询方式获得结果

在这里插入图片描述

#include<iostream>
#include<algorithm>

using namespace std;

typedef  long long LL;

const int N=2010,mod=1e9+7;

int c[N][N];

void init(){
    //初始化c[N][N]0~2000的所有组合数对形如c[0][0],c[1][0],c[2][0]...的应当等于1
    for(int i=0;i<N;i++){
        
        for(int j=0;j<=i;j++){        //初始化斜对角线的一半数据即可
            
            if(!j)c[i][j]=1;
            
            else c[i][j]=(LL)(c[i-1][j]+c[i-1][j-1])%mod;    //相加时可能溢出,应当转化成longlong 
            
        }
        
    }
    
}


int main(){
    
    init();
    
    int n;
    
    cin>>n;
    
    while(n--){
        
        int a,b;
        
        cin>>a>>b;
        
        cout<<c[a][b]<<endl;
        
    }
    
    return 0;
    
}

886求组合数II（nlogn）

方式二：
用快速幂预处理出fact（阶乘）数组以及infact（阶乘的逆元）数组

  • fact[i]表示 i !   m o d   1 0 7 + 1 i! \ mod \ 10 ^ 7 +1 i! mod 107+1
  • infact[i]表示 i !   − 1   m o d   1 0 7 + 1 i! \ ^ {-1} \ mod \ 10 ^ 7 +1 i! −1 mod 107+1
  • fact[i]和infact[i]互为倒数
  • 最后用递推公式求得结果
  • 逆元采用快速幂的方式来求， ( k ! ) − 1 (k!)^{−1} (k!)−1 = = = ( ( k − 1 ) ! ) − 1 × k − 1 ((k−1)!)^{−1}×k^{−1} ((k−1)!)−1×k−1
  • 组合数就等于对应数组相乘的值，避免了除法运算
  • 时间复杂度分析:a,b,上限N（105）乘以快速幂时间复杂度log(mod)
  • N l o g ( m o d ) + N Nlog(mod)+N Nlog(mod)+N约等于10万

在这里插入图片描述
在这里插入图片描述

#include<iostream>
#include<algorithm>

using namespace std;

typedef long long  LL;

const int N=1e5+10,mod=1e9+7;

int fact[N],infact[N];

//快速幂用于求逆元
int qmi(int a,int k){
    
    int res=1;
    
    while(k){
        
        if(k&1)res=(LL)res*a%mod;
        
        a=(LL)a*a%mod;
        
        k=k>>1;
        
    }
    
    return res;
}

int main(){
    
    fact[0]=infact[0]=1;
    
    //预处理出i!%mod 和i!^-1 %mod
    for(int i=1;i<N;i++){
        
        fact[i]=(LL)fact[i-1]*i%mod;
        
        infact[i]=(LL)infact[i-1]*qmi(i,mod-2)%mod;
    }
    
    int n;
    
    cin>>n;
    
    while(n--){
        
        int a,b;
        
        int res;
        
        cin>>a>>b;
        
        res=(LL)fact[a]*infact[b]%mod*infact[a-b]%mod;     //递推公式算出结果
        //注意不能写成简化公式res=(LL)fact[a-b+1]*infact[b]%mod;
        
        cout<<res<<endl;
        
    }
    
    
}

887求组合数III(plogn)

卢卡斯定理: C ( b a ) ≡ C ( b   m o d   p a   m o d   p ) ∗ C ( b / p a / p ) C\tbinom{b}{a} \equiv C\tbinom{b\ mod\ p}{a\ mod \ p} *C\tbinom{b / p}{a / p} C(ab​)≡C(a mod pb mod p​)∗C(a/pb/p​)

在这里插入图片描述

在这里插入图片描述

#include<iostream>
#include<algorithm>

using namespace  std;

typedef long long LL;

int p;

int qmi(int a,int k){         //快速幂求逆元
    int res=1;
    
    while(k){
        if(k&1)res=(LL)res*a%p;
        
        k>>=1;
        
        a=(LL)a*a%p;
    }
    
    return res;
}

int c(int a,int b){                  //定义求组合数
    int res=1;
    
    for(int i=a,j=1; j<=b ;i--,j++){   //即a*(a-1)*...*(a-b+1)/b! 此处b求逆元
        res=(LL)res*i%p;
        
        res=(LL)res*qmi(j,p-2)%p;
    }
    
    return res;
}

int lucas(LL a,LL b){
    if(a<p&&b<p)return c(a,b);                     //ab均小于p，返回定义求逆元
    
    else return (LL)c(a%p,b%p)*lucas(a/p,b/p)%p;    //否则对a,b降阶
}  

int main(){
    
    int n;
    
    cin>>n;
    
    while(n--){
        LL a,b;
        
        cin>>a>>b>>p;
        
        cout<<lucas(a,b)<<endl;
    }
    
}

888求组合数IV **

在这里插入图片描述

  • 将组合数拆解成质因数相乘的形式，这样只利用到高精度乘法而不用高精度除法
  • 例如计算 C 30 20 C_{30}^{20} C3020​将30的质因数(2,3,5,7,11…29)筛出来 那么组合数可以表示成
  • 2 a 1 × 3 a 2 × 5 a 3 × . . . × 2 9 a n 2^{a1} \times 3^{a2}\times 5^{a3}\times...\times29^{an} 2a1×3a2×5a3×...×29an
  • 其中次数的计算 如30！中2的次数应该是 :由 ⌊ 30 / 2 ⌋ + ⌊ 30 / 2 2 ⌋ + ⌊ 30 / 2 3 ⌋ + ⌊ 30 / 2 4 ⌋ \lfloor 30/2 \rfloor+\lfloor 30/2^2 \rfloor+\lfloor 30/2^3 \rfloor+\lfloor 30/2^4 \rfloor ⌊30/2⌋+⌊30/22⌋+⌊30/23⌋+⌊30/24⌋ (2^5>30所以不除
  • 而总的次数应该由上下阶乘共同决定如 a 3 = ⌊ 30 / 5 ⌋ + ⌊ 30 / 5 2 ⌋ − ⌊ 20 / 5 ⌋ − ⌊ ( 30 − 20 ) / 5 ⌋ a_3= \lfloor 30/5 \rfloor+\lfloor 30/5^2 \rfloor - \lfloor 20/5\rfloor -\lfloor (30-20)/5\rfloor a3​=⌊30/5⌋+⌊30/52⌋−⌊20/5⌋−⌊(30−20)/5⌋

算法：

  1. 找到较大数a(1~a)中所有的质数因子 （线性筛质因数）
  2. 将各个质数因子对应的次数计算出来
  3. 利用高精度乘法将各项相乘得出答案

在这里插入图片描述

#include<iostream>
#include<vector>

using namespace std;

const int N=5010;

int primes[N],st[N],cnt;

int sums[N];

//求1~n质因数
void  get_primes(int n){
    
    for(int i=2;i<=n;i++){
        
        if(!st[i])primes[cnt++]=i;
        
        for(int j=0;primes[j]<=n/i;j++){
            
            st[primes[j]*i]=true;
            
            if(i%primes[j]==0)break;
        }
    }
}

//求各个质因数的系数
int get(int n,int p){
    int res=0;
    
    while(n){
        res+=n/p;
        
        n/=p;
        
    }
    
    return res;
}

vector<int> mul(vector<int> a, int b){
    vector<int> res;
    
    int t=0;
    
    for(int i=0;i<a.size()|t;i++){
        if(i<a.size())t=a[i]*b+t;
        
        res.push_back(t%10);
        
        t/=10;
    }
    
    return res;
}


int main(){
    
    int a,b;
    
    cin>>a>>b;
    
    get_primes(a);
    
    for(int i=0;i<cnt;i++){
        int p=primes[i];
        
        sums[i]=get(a,p)-get(b,p)-get(a-b,p);
    }
    
    vector<int> res;
    
    res.push_back(1);
    
    for(int i=0;i<cnt;i++)          //对于每一个质因子`primes[i]`都要乘以他的对应次数`sums[i]`次
      for(int j=0;j<sums[i];j++)
          res=mul(res,primes[i]);
     
    for(int i=res.size()-1;i>=0;i--)cout<<res[i];
    
    return 0;
    
}

889.满足条件的01序列

在这里插入图片描述

算法样例：

  • 设n=6,将每一种方案组合映射到二维空间的路径，规定数字0代表向右走一格，数字1代表向上走一格
  • 那么无论满不满足条件的路径都会以(6,6)为终点，其中总的路径数应当为 C 12 6 C_{12}^6 C126​(代表选6次向上走)
  • 我们的目的是求出其中不满足条件的方案,任意前缀中的0>=1的个数，对应到二维空间，即为对于任意一个点(x,y),x>=y即经过红线以及红线以上的点的路径均不满足条件
  • 我们假设一条不满足条件的路径，那么路径一定经过红线，并最终到达(6,6)，我们以这条红线为对称轴，将终点(6,6)对应到另外一个终点(5,7)，
  • 所以所有不满足条件的路径经过对称一定可以走到另一个终点(5,7),而所有经过(5,7)的路径一定经过了红线，所以到达(5,7)的路径全部是不满足条件的路径，最终满足条件的路径就是 C 12 6 − C 12 5 = 1 7 C 12 6 C_{12}^6-C_{12}^{5}=\frac{1}{7}C_{12}^{6} C126​−C125​=71​C126​

卡特兰数： C 2 n n − C 2 n n − 1 = 1 n + 1 C 2 n n C_{2n}^{n}-C_{2n}^{n-1}= \frac{1}{n+1}C_{2n}^{n} C2nn​−C2nn−1​=n+11​C2nn​

  • C 2 n n − C 2 n n − 1 = ( 2 n ) ! n ! ∗ n ! − ( 2 n ) ! ( n + 1 ) ! ∗ ( n − 1 ) ! = ( n + 1 ) ∗ ( 2 n ) ! − n ∗ ( 2 n ) ! n ! ∗ ( n + 1 ) ! = ( 2 n ) ! n ! ∗ ( n + 1 ) ! = 1 ( n + 1 ) ∗ ( 2 n ) ! n ! ∗ n ! = 1 ( n + 1 ) C 2 n n C_{2n}^{n}-C_{2n}^{n-1}= \frac{(2n)!} {n!*n!} -\frac{(2n)!}{(n+1)!*(n-1)!}=\frac{(n+1)*(2n)!-n*(2n)!}{n!*(n+1)!}=\frac {(2n)!}{n!*(n+1)!}=\frac{1}{(n+1)}*\frac{(2n)!} {n!*n!}=\frac{1}{(n+1)}C_{2n}^{n} C2nn​−C2nn−1​=n!∗n!(2n)!​−(n+1)!∗(n−1)!(2n)!​=n!∗(n+1)!(n+1)∗(2n)!−n∗(2n)!​=n!∗(n+1)!(2n)!​=(n+1)1​∗n!∗n!(2n)!​=(n+1)1​C2nn​

在这里插入图片描述

#include<iostream>

using namespace std;

const int  mod=1e9+7;

typedef  long long LL;

int qmi(int a,int k){
    int res=1;
    
    while(k){
        if(k&1)res=(LL)res*a%mod;
        
        k>>=1;
        
        a=(LL)a*a%mod;
    }
    
    return res;
}

int main(){
    int n;
    
    cin>>n;
    
    int a=2*n,b=n;
    
    int res=1;
    
    //定义法求组合数
    for(int i=a,j=1;j<=b;j++,i--){
        res=(LL)res*i%mod;
        
        res=(LL)res*qmi(j,mod-2)%mod;
    }
    
    res=(LL)res*qmi(n+1,mod-2)%mod;
    
    cout<<res;
}
zzcxxoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数论3 二项式定理、卢卡斯定理和卡特兰数
Eric_bells的博客
07-30 166
但这会有问题了，中间那一小块也被削掉了（深蓝绿色弧边三角），而ABC共有的部分是不可以削掉的，所以再加回来。还有，希望大家多多点赞加关注，你们的三连是我的动力，我会持续推送高质量的文章哦~我们用个简单点的办法杨辉三角（帕斯卡三角），可以在O(n²)时间下解决对某一个数取余的问题，n的范围限制为10³——5*10³级别。所以我们用O(m）的时间把ln(x)的前缀和算出来，就能O（1）的时间计算结果（几乎相当于秒出答案），但误差有点多。这四个字的意思就一句话削掉重复的，再把多削的部分加回来。...
数论3（高斯消元+求组合数）
小羊的博客
03-30 692
数论3 高斯消元 高斯消元解线性方程组 高斯消元解异或线性方程组 求组合数 求组合数 I 求组合数 II 求组合数 III 求组合数 IV 满足条件的01序列
PHP获取字符串的所有子集,PHP Regexp(PCRE)-查找所有子字符串的集合
weixin_39705931的博客
03-25 1540
我有以下字符串,例如：aaXXccYYeeXX_ZZkkYYmmXX_ZZnnXXooYYuuXX_ZZvv如何在字符串中找到所有XX.* YY.* ZZ部分？ (可能通过使用preg_match())> XX cc YY eeXX_ ZZ> XX _ZZkk YY毫米XX_ ZZ> XX _ZZnnXXoo YY uuXX_ ZZ> XX oo YY uuXX_ ZZ加上...
xxoo
热门推荐
qq_45041558的博客
11-19 8万+
time = input(‘请输入日期 YYYY-MM-DD：’) date = time.split(’-’) year = int(date[0]) month = int(date[1]) day = int(date[2]) li = [31,28,31,30,31,30,31,31,30,31,30,31] num = 0 if((year%40))and(year%100!=0)or(...
全站a链接新窗口打开
pjwan的专栏
11-14 2628
$(document).ready(function($) { $('a').attr({ target: "_blank" }); });
ACM数学+数论大全
03-12
三-素数问题 6 素数性质 6 素数猜想 6 素数测试 6 筛素数 7 区间筛素数 7 大素数测试 7 素因子相关 8 梅森素数 8 筛可以表示成x^2+(x+1)^2的素数 9 高斯整数环与高斯素数 10 n!中素数y的个数 10 筛1~n的因子个数O(n)...
C++数学与算法之初等数论
12-27
本文主要讲解了C++数学与算法系列之初等数论，涵盖了数的定义、数的进制、数论的概念、欧几里德算法等知识点。 数的定义：数是一个抽象概念，用于计数、标记或用作量度。数可以表示为数字、运算符号等记数系统。在...
数学竞赛 数论PPT课件.pptx
10-08
本资源是一个数学竞赛数论PPT课件，总共27页，涵盖了整数的奇偶性和整除性、同余的定义和性质等知识点。下面是对这些知识点的详细解释： 一、整数的奇偶性 * 整数的奇偶性是指整数是奇数还是偶数。 * 两个整数的和...
数论 数论 集合 计算机 数学
09-05
这是一个初步介绍数论知识的课件 这是一个真正数论的开始
数学知识+算法的详解
10-25
包括：卷积（运算、定理、应用），大整数乘法，大数除法（牛顿迭代法、倍增法），多项式乘法，多项式除法，生成函数（线性递推、Catalan数），多重集合组合数，正整数剖分，指数生成函数，牛顿迭代法，数论转化，...
nacos的安装和配置(亲测过,少入坑)
u011743212的博客
05-19 2731
1.下载： https://github.com/alibaba/nacos 配置中下载:https://github.com/alibaba/nacos/releases 如果下载不了,下面是网盘的下载地址 linux安装包链接: https://pan.baidu.com/s/12Brx-fh0DgESzhAtn09SIw 提取码: fxck window安装包链接: https://pan.baidu.com/s/1GGrGfNcLy3p5msW5wfm58A 提取码:...
QTcpServer多客户端连接
Leroy888的博客
05-24 2535
Qt默认的QTcpServer有新的连接时会触发newConnection信号，在其对应的槽函数中new QTcpSocket， 通过new的QTcpSocket对象接受发送数据，当有多客户端连接时，Server端接受的数据将不容易分辨是哪个客户端的socket发送的数据，解决这个问题的办法是重写QTcpServer中的incomingConnection(qintptr handle)函数，当有新的连接时，会调用该函数，在该函数中new 一个Socket的，并将函数中的参数handle传递给new的soc
深入理解时间和空间复杂度
k666499436的博客
04-27 1万+
时间复杂度：算法中的`基本语句重复的执行次数 空间复杂度：空间复杂度算的是变量的个数
python整理-Day3
weixin_30748995的博客
05-28 92
set 无须，不重复,可嵌套的集合 1 class set(object): 2 """ 3 set() -> new empty set object 4 set(iterable) -> new set object 5 6 Build an unordered collection o...
[Linux][Nginx][01]Install
weixin_34247032的博客
08-24 41
VERSION=1.13.0 wget -P /tmp http://nginx.org/download/nginx-$VERSION.tar.gz # 安装必要的组件 yum install -y gcc pcre* openssl-devel # 创建组和用户 groupadd nginx useradd -g nginx nginx -s /sbin/nologin # ...
（数论三）素数原理
Ivan_zcy的博客
10-21 1906
​ 打算写一下自己对ACM中常用到的数论知识，加深巩固和查缺补漏。 ​ 在数学中，对于n&gt;1,若n的因子只有1和它本身，那么n就是质数，也称作素数。而在ACM中素数类型的题目是经常会碰到的。 ​ 那么我们可以怎么判断素数呢？ 一.对于判断单个n是否为素数，我们可以通过三种情况来判断： ​ （1）用i遍历2~ n -1，若n % i == 0就代表存在除1和它本身以外的因子，就直接跳出，若执行...
初等数论三
宋清的博客
06-08 587
初等数论三剩余类和完全剩余系定理1威尔逊定理缩系定义1定义2定理2定理3定理4定理5 欧拉定理定理6 费马小定理定理7推论定理8一次同余式定义3定理9定理10定理11模是素数的同余式定理12 拉格朗日定理定理13定理14 剩余类和完全剩余系 定理1威尔逊定理 设p是一个素数，则(p−1)!+1≡0(mod  p)(p-1)!+1\equiv 0(\mod p)(p−1)!+1≡0(modp) 证明 充分性 以下的-1都是在模p意义下的，实际上就是p-1。 我们知道1∗1≡1(mod  p),(−1)∗(−
算法运行时间1、logN、N、NlogN 、N^2、N^3、2^n之间的比较
隔壁老瓦的专栏
05-09 1万+
排序算法中，常常要求我们估算出最坏情况运行时间和平均情况/期望运行时间。在估算运行时间时，我们常用到下面一些时间量： 1 大部分程序的大部分指令之执行一次，或者最多几次。如果一个程序的所有指令都具有这样的性质，我们说这个程序的执行时间是常数。 logN 如果一个程序的运行时间是对数级的，则随着N的增大程序会渐渐慢下来，如果一个程序将一个大的问题分解成一系列更小的问题，每...
acwing算法基础课数学知识
最新发布
10-18
好的，关于 acwing 算法基础课中的数学知识，我可以为您提供一些基本的概述。 在 acwing 算法基础课中，数学知识主要包括以下几个方面： 1. 基本数论：包括质数、约数、欧拉函数、同余等概念和相关算法。 2. 组合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值