数论-模板

最新推荐文章于 2022-06-29 23:31:50 发布
最新推荐文章于 2022-06-29 23:31:50 发布
阅读量668 收藏
点赞数
分类专栏： 模板 数论 文章标签： 数论 模板

1.扩展的欧几里德定理

[cpp] view plain copy print ?
  1. //拓展欧几里得定理，求ax+by=gcd(a,b)的一组解(x,y),d=gcd(a,b)
  2. void gcd(int a,int b,int &d,int &x,int &y)
  3. {
  4. if(!b){d=a;x=1;y=0;}
  5. else{gcd(b,a%b,d,y,x);y-=x*(a/b);}
  6. } 
//拓展欧几里得定理，求ax+by=gcd(a,b)的一组解(x,y),d=gcd(a,b)
void gcd(int a,int b,int &d,int &x,int &y)
{
    if(!b){d=a;x=1;y=0;}
    else{gcd(b,a%b,d,y,x);y-=x*(a/b);}
}

用法1：

求ax+by=c的整数解。ax+by=gcd(a,b)=g的一组解为(x0,y0),则ax+by=c的一组解为(x0*c/g,y0*c/g)。当c不是g的倍数时无整数解

若(x1,y1)是ax+by=c的一组解，则其任意整数解为(x1+k*bb,y1-k*aa)，其中aa=a/gcd(a,b),bb=b/gcd(bb)，k为任意整数

2.求模乘法的逆

[cpp] view plain copy print ?
  1. //求得a在模n条件下的逆
  2. int inv(int a,int n)
  3. {
  4. int d,x,y;
  5. gcd(a,n,d,x,y);
  6. return d==1?(x+n)%n:-1;
  7. } 
//求得a在模n条件下的逆
int inv(int a,int n)
{
   int d,x,y;
   gcd(a,n,d,x,y);
   return d==1?(x+n)%n:-1;
}

或则：

[cpp] view plain copy print ?
  1. v=pow_mod(a,n-m-1,n);//n为素数，pow_mod(a,n-1,n)=1,费马小定理。所以a^m*a^(n-m-1)=a^(n-1)=1(mod n).
v=pow_mod(a,n-m-1,n);//n为素数，pow_mod(a,n-1,n)=1,费马小定理。所以a^m*a^(n-m-1)=a^(n-1)=1(mod n).

3.快速幂求解a^b

[cpp] view plain copy print ?
  1. //快速幂求a^b
  2. int pow_mod(int a,int b)
  3. {
  4. int s=1;
  5. while(b)
  6. {
  7. if(b&1)
  8. s=(s*a)%mod;
  9. a=(a*a)%mod;
  10. b=b>>1;
  11. }
  12. return s;
  13. } 
//快速幂求a^b
int pow_mod(int a,int b)
{
    int s=1;
    while(b)
    {
        if(b&1)
            s=(s*a)%mod;
        a=(a*a)%mod;
        b=b>>1;
    }
    return s;
}

4.求解模方程a^x=b(mod n)。

1.n为素数。无解返回-1

[cpp] view plain copy print ?
  1. //求解模方程a^x=b(mod n)。n为素数，无解返回-1
  2. int log_mod (int a,int b,int n)
  3. {
  4. int m,v,e=1,i;
  5. m=ceil(sqrt(n+0.5));
  6. v=inv(pow_mod(a,m),n);
  7. map<int,int>x;
  8. x[1]=0;
  9. for(i=1;i<m;i++)
  10. {
  11. e=(e*a)%n;
  12. if(!x.count(e))x[e]=i;
  13. }
  14. for(i=0;i<m;i++)
  15. {
  16. if(x.count(b))return i*m+x[b];
  17. b=(b*v)%n;
  18. }
  19. return -1;
  20. } 
//求解模方程a^x=b(mod n)。n为素数，无解返回-1
int log_mod (int a,int b,int n)
{
    int m,v,e=1,i;
    m=ceil(sqrt(n+0.5));
    v=inv(pow_mod(a,m),n);
    map<int,int>x;
    x[1]=0;
    for(i=1;i<m;i++)
    {
        e=(e*a)%n;
        if(!x.count(e))x[e]=i;
    }
    for(i=0;i<m;i++)
    {
        if(x.count(b))return i*m+x[b];
        b=(b*v)%n;
    }
    return -1;
}

2.n不是素数。

[cpp] view plain copy print ?
  1. //hdu 2815 Mod Tree
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <cmath>
  5. #include <map>
  6. #include <iostream>
  7. #include <algorithm>
  8. using namespace std;
  9. #define LL __int64
  10. LL gcd(LL a,LL b)
  11. {
  12. return b==0?a:gcd(b,a%b);
  13. }
  14. //拓展欧几里得定理，求ax+by=gcd(a,b)的一组解(x,y),d=gcd(a,b)
  15. void gcd_mod(LL a,LL b,LL &d,LL &x,LL &y)
  16. {
  17. if(!b){d=a;x=1;y=0;}
  18. else{gcd_mod(b,a%b,d,y,x);y-=x*(a/b);}
  19. }
  20. //求解模方程d*a^(x-c)=b(mod n)。d,a和n互质，无解返回-1
  21. LL log_mod (LL a,LL b,LL n,LL c,LL d)
  22. {
  23. LL m,v,e=1,i,x,y,dd;
  24. m=ceil(sqrt(n+0.5)); //x=i*m+j
  25. map<LL,LL>f;
  26. f[1]=m;
  27. for(i=1;i<m;i++) //建哈希表，保存a^0,a^1,...,a^m-1
  28. {
  29. e=(e*a)%n;
  30. if(!f[e])f[e]=i;
  31. }
  32. e=(e*a)%n;//e=a^m
  33. for(i=0;i<m;i++)//每次增加m次方，遍历所有1<=f<=n
  34. {
  35. gcd_mod(d,n,dd,x,y);//d*x+n*y=1-->(d*x)%n=1-->d*(x*b)%n==b
  36. x=(x*b%n+n)%n;
  37. if(f[x])
  38. {
  39. LL num=f[x];
  40. f.clear();//需要清空，不然会爆内存
  41. return c+i*m+(num==m?0:num);
  42. }
  43. d=(d*e)%n;
  44. }
  46. return -1;
  47. }
  48. int main()
  49. {
  50. LL a,b,n;
  51. while(scanf("%I64d%I64d%I64d",&a,&n,&b)!=EOF)
  52. {
  53. if(b>=n)
  54. {
  55. printf("Orz,I can’t find D!\n");
  56. continue;
  57. }
  58. if(b==0)
  59. {
  60. printf("0\n");
  61. continue;
  62. }
  63. LL ans=0,c=0,d=1,t;
  64. while((t=gcd(a,n))!=1)
  65. {
  66. if(b%t){ans=-1;break;}
  67. c++;
  68. n=n/t;
  69. b=b/t;
  70. d=d*a/t%n;
  71. if(d==b){ans=c;break;}//特判下是否成立。
  72. }
  73. if(ans!=0)
  74. {
  75. if(ans==-1){printf("Orz,I can’t find D!\n");}
  76. else printf("%I64d\n",ans);
  77. }
  78. else
  79. {
  80. ans=log_mod(a,b,n,c,d);
  81. if(ans==-1)printf("Orz,I can’t find D!\n");
  82. else printf("%I64d\n",ans);
  83. }
  84. }
  85. return 0;
  86. }
  87. /*
  88. 求解模方程a^x=b(mod n)，n不为素数。拓展Baby Step Giant Step
  89. 模板题。
  91. 方法：
  92. 初始d=1,c=0,i=0;
  93. 1.令g=gcd(a,n),若g==1则执行下一步。否则由于a^x=k*n+b;(k为某一整数),则(a/g)*a^k=k*(n/g)+b/g,(b/g为整除，若不成立则无解)
  94. 令n=n/g，d=d*a/g，b=b/g,c++则d*a^(x-c)=b(mod n),接着重复1步骤。
  95. 2.通过1步骤后，保证了a和d都与n互质，方程转换为d*a^(x-c)=b(mod n)。由于a和n互质，所以由欧拉定理a^phi(n)==1(mod n),(a,n互质)
  96. 可知，phi(n)<=n,a^0==1(mod n),所以构成循环，且循环节不大于n。从而推出如果存在解，则必定1<=x<n。(在此基础上我们就可以用
  97. Baby Step Giant Step方法了)
  98. 3.令m=ceil(sqrt(n)),则m*m>=n。用哈希表存储a^0,a^1,..,a^(m-1)，接着判断1~m*m-1中是否存在解。
  99. 4.为了减少时间，所以用哈希表缩减复杂度。分成m次遍历，每次遍历a^m长度。由于a和d都与n互质，所以gcd(d,n)=1，
  100. 所以用拓展的欧几里德定理求得d*x+n*y=gcd(d,n)=1,的一组整数解(x,y)。则d*x+n*y=1-->d*x%n=(d*x+n*y)%n=1-->d*(x*b)%n=((d*x)%n*b%n)%n=b。
  101. 所以若x*b在哈希表中存在，值为k，则a^k*d=b(mod n),答案就是ans=k+c+i*m。如果不存在，则令d=d*a^m,i++后遍历下一个a^m，直到遍历a^0到a^(m-1)还未找到，则说明不解并退出。
  103. */ 
//hdu 2815 Mod Tree
#include <cstdio>
#include <cstring>
#include <cmath>
#include <map>
#include <iostream>
#include <algorithm>
using namespace std;
#define LL __int64
LL gcd(LL a,LL b)
{
    return b==0?a:gcd(b,a%b);
}
//拓展欧几里得定理，求ax+by=gcd(a,b)的一组解(x,y),d=gcd(a,b)
void gcd_mod(LL a,LL b,LL &d,LL &x,LL &y)
{
    if(!b){d=a;x=1;y=0;}
    else{gcd_mod(b,a%b,d,y,x);y-=x*(a/b);}
}
//求解模方程d*a^(x-c)=b(mod n)。d,a和n互质，无解返回-1
LL log_mod (LL a,LL b,LL n,LL c,LL d)
{
    LL m,v,e=1,i,x,y,dd;
    m=ceil(sqrt(n+0.5));     //x=i*m+j
    map<LL,LL>f;
    f[1]=m;
    for(i=1;i<m;i++)  //建哈希表，保存a^0,a^1,...,a^m-1
    {
        e=(e*a)%n;
        if(!f[e])f[e]=i;
    }
    e=(e*a)%n;//e=a^m
    for(i=0;i<m;i++)//每次增加m次方，遍历所有1<=f<=n
    {
        gcd_mod(d,n,dd,x,y);//d*x+n*y=1-->(d*x)%n=1-->d*(x*b)%n==b
        x=(x*b%n+n)%n;
        if(f[x])
        {
            LL num=f[x];
            f.clear();//需要清空，不然会爆内存
            return c+i*m+(num==m?0:num);
        }
        d=(d*e)%n;
    }

    return -1;
}
int main()
{
    LL a,b,n;
    while(scanf("%I64d%I64d%I64d",&a,&n,&b)!=EOF)
    {
        if(b>=n)
        {
            printf("Orz,I can’t find D!\n");
            continue;
        }
        if(b==0)
        {
            printf("0\n");
            continue;
        }
        LL ans=0,c=0,d=1,t;
        while((t=gcd(a,n))!=1)
        {
            if(b%t){ans=-1;break;}
            c++;
            n=n/t;
            b=b/t;
            d=d*a/t%n;
            if(d==b){ans=c;break;}//特判下是否成立。
        }
        if(ans!=0)
        {
            if(ans==-1){printf("Orz,I can’t find D!\n");}
            else printf("%I64d\n",ans);
        }
        else
        {
            ans=log_mod(a,b,n,c,d);
            if(ans==-1)printf("Orz,I can’t find D!\n");
            else printf("%I64d\n",ans);
        }
    }
    return 0;
}
/*
    求解模方程a^x=b(mod n)，n不为素数。拓展Baby Step Giant Step
    模板题。
    
    方法：
    初始d=1,c=0,i=0;
    1.令g=gcd(a,n),若g==1则执行下一步。否则由于a^x=k*n+b;(k为某一整数),则(a/g)*a^k=k*(n/g)+b/g,(b/g为整除，若不成立则无解)
令n=n/g，d=d*a/g，b=b/g,c++则d*a^(x-c)=b(mod n),接着重复1步骤。
    2.通过1步骤后，保证了a和d都与n互质，方程转换为d*a^(x-c)=b(mod n)。由于a和n互质，所以由欧拉定理a^phi(n)==1(mod n),(a,n互质)
可知，phi(n)<=n,a^0==1(mod n),所以构成循环，且循环节不大于n。从而推出如果存在解，则必定1<=x<n。(在此基础上我们就可以用
Baby Step Giant Step方法了)
    3.令m=ceil(sqrt(n)),则m*m>=n。用哈希表存储a^0,a^1,..,a^(m-1)，接着判断1~m*m-1中是否存在解。
    4.为了减少时间，所以用哈希表缩减复杂度。分成m次遍历，每次遍历a^m长度。由于a和d都与n互质，所以gcd(d,n)=1，
所以用拓展的欧几里德定理求得d*x+n*y=gcd(d,n)=1,的一组整数解(x,y)。则d*x+n*y=1-->d*x%n=(d*x+n*y)%n=1-->d*(x*b)%n=((d*x)%n*b%n)%n=b。
所以若x*b在哈希表中存在，值为k，则a^k*d=b(mod n),答案就是ans=k+c+i*m。如果不存在，则令d=d*a^m,i++后遍历下一个a^m，直到遍历a^0到a^(m-1)还未找到，则说明不解并退出。

*/



5.中国剩余定理

互质情况

[cpp] view plain copy print ?
  1. //中国剩余定理，求得M%A=a,M%B=b,...中的M，其中A,B,C...互质
  2. int china(int a[])
  3. {
  4. int i,j,k,d,ans=0,x,y,M=1;
  5. for(i=0;i<n;i++)
  6. M=M*x[i];
  7. for(i=0;i<n;i++)
  8. {
  9. m=M/x[i];
  10. gcd(x[i],m,d,x,y);
  11. ans=(ans+y*m*a[i])%M;
  12. }
  13. return (ans+M)%M;
  14. } 
//中国剩余定理，求得M%A=a,M%B=b,...中的M，其中A,B,C...互质  
int china(int a[])
{  
    int i,j,k,d,ans=0,x,y,M=1;
    for(i=0;i<n;i++)  
        M=M*x[i];
    for(i=0;i<n;i++)  
    {  
        m=M/x[i];  
        gcd(x[i],m,d,x,y);  
        ans=(ans+y*m*a[i])%M;  
    }  
    return (ans+M)%M;  
}

不互质的情况

[cpp] view plain copy print ?
  1. int China(int n)
  2. {
  3. int m1,r1,m2,r2,flag=0,i,d,x,y,c,t;
  4. scanf("%d%d",&m1,&r1);
  5. flag=0;
  6. for(i=1;i<n;i++)
  7. {
  8. scanf("%d%d",&m2,&r2);
  9. if(flag)continue;
  10. gcd(m1,m2,d,x,y);//d=gcd(m1,m2);x*m1+y*m2=d;
  11. c=r2-r1;
  12. if(c%d)//对于方程m1*x+m2*y=c，如果c不是d的倍数就无整数解
  13. {
  14. flag=1;
  15. continue;
  16. }
  17. t=m2/d;//对于方程m1x+m2y=c=r2-r1,若(x0,y0)是一组整数解,那么(x0+k*m2/d,y0-k*m1/d)也是一组整数解(k为任意整数)
  18. //其中x0=x*c/d,y0=x*c/d;
  19. x=(c/d*x%t+t)%t;//保证x0是正数，因为x+k*t是解，(x%t+t)%t也必定是正数解(必定存在某个k使得(x%t+t)%t=x+k*t)
  20. r1=m1*x+r1;//新求的r1就是前i组的解，Mi=m1*x+M(i-1)=r2-m2*y(m1为前i个m的最小公倍数);对m2取余时，余数为r2；
  21. //对以前的m取余时，Mi%m=m1*x%m+M(i-1)%m=M(i-1)%m=r
  22. m1=m1*m2/d;
  23. }
  24. if(flag)return -1;
  25. else return r1;
  26. } 
int China(int n)  
{  
    int m1,r1,m2,r2,flag=0,i,d,x,y,c,t;  
    scanf("%d%d",&m1,&r1);  
    flag=0;  
    for(i=1;i<n;i++)  
    {  
        scanf("%d%d",&m2,&r2);  
        if(flag)continue;  
        gcd(m1,m2,d,x,y);//d=gcd(m1,m2);x*m1+y*m2=d;  
        c=r2-r1;  
        if(c%d)//对于方程m1*x+m2*y=c，如果c不是d的倍数就无整数解  
        {  
            flag=1;  
            continue;  
        }  
        t=m2/d;//对于方程m1x+m2y=c=r2-r1,若(x0,y0)是一组整数解,那么(x0+k*m2/d,y0-k*m1/d)也是一组整数解(k为任意整数)  
                //其中x0=x*c/d,y0=x*c/d;  
        x=(c/d*x%t+t)%t;//保证x0是正数，因为x+k*t是解，(x%t+t)%t也必定是正数解(必定存在某个k使得(x%t+t)%t=x+k*t)  
        r1=m1*x+r1;//新求的r1就是前i组的解，Mi=m1*x+M(i-1)=r2-m2*y(m1为前i个m的最小公倍数);对m2取余时，余数为r2；  
                    //对以前的m取余时，Mi%m=m1*x%m+M(i-1)%m=M(i-1)%m=r  
        m1=m1*m2/d;  
    }  
    if(flag)return -1; 
    else return r1;  
}


6.素数

普通筛选法

[cpp] view plain copy print ?
  1. const int maxn=10000001;
  2. const int maxc=700000;
  3. int vis[maxn];//vis[i]=0时，i为素数或者1，否则为合数
  4. int prime[maxc];
  5. //筛素数
  6. void sieve(int n)
  7. {
  8. int m=(int)sqrt(n+0.5);//避免浮点误差
  9. memset(vis,0,sizeof(vis));
  10. for(int i=2;i<=m;i++)if(!vis[i])
  11. for(int j=i*i;j<=n;j+=i)vis[j]=1;
  12. }
  13. //生成素数表,存在prime数组中，返回素数个数
  14. int primes(int n)
  15. {
  16. sieve(n);
  17. int t=0;
  18. for(int i=2;i<=n;i++)if(!vis[i])
  19. prime[t++]=i;
  20. return t;
  21. } 
const int maxn=10000001;
const int maxc=700000;
int vis[maxn];//vis[i]=0时，i为素数或者1，否则为合数
int prime[maxc];
//筛素数
void sieve(int n)
{
    int m=(int)sqrt(n+0.5);//避免浮点误差
    memset(vis,0,sizeof(vis));
    for(int i=2;i<=m;i++)if(!vis[i])
        for(int j=i*i;j<=n;j+=i)vis[j]=1;
}
//生成素数表,存在prime数组中，返回素数个数
int primes(int n)
{
    sieve(n);
    int t=0;
    for(int i=2;i<=n;i++)if(!vis[i])
        prime[t++]=i;
    return t;
}

线性筛法

：在O（n）时间复杂度内找出所有的素数

[cpp] view plain copy print ?
  1. void init()//预处理，找出所有1e7以内的素数，以减少查找1e14范围数的因子的时间
  2. { //现行筛素数的方法，时间复杂度为O(n)
  3. memset(check,false,sizeof(check));
  4. int i,j;
  5. tot=0;
  6. for(i=2;i<=1e7;i++)
  7. {
  8. if(!check[i])prime[tot++]=i;
  9. for(j=0;j<tot;j++)
  10. {
  11. if(i*prime[j]>1e7)break;
  12. check[i*prime[j]]=true;
  13. if(i%prime[j]==0)break;
  14. }
  15. }
  16. //printf("%d\n",tot);
  17. //for(i=0;i<20;i++)
  18. // printf("prime[%d]:%d\n",i,prime[i]);
  19. } 
void init()//预处理，找出所有1e7以内的素数，以减少查找1e14范围数的因子的时间  
{           //现行筛素数的方法，时间复杂度为O(n)  
    memset(check,false,sizeof(check));  
    int i,j;  
    tot=0;  
    for(i=2;i<=1e7;i++)  
    {  
        if(!check[i])prime[tot++]=i;  
        for(j=0;j<tot;j++)  
        {  
            if(i*prime[j]>1e7)break;  
            check[i*prime[j]]=true;  
            if(i%prime[j]==0)break;  
        }  
    }  
    //printf("%d\n",tot);  
    //for(i=0;i<20;i++)  
    //    printf("prime[%d]:%d\n",i,prime[i]);  
}




7.欧拉phi函数

，求不超过n且与n互质的正整数个数

[cpp] view plain copy print ?
  1. int euler_phi(int n)//求单个欧拉函数
  2. {
  3. int m=(int)sqrt(n+0.5);
  4. int i,ans=n;
  5. for(i=2;i<=m;i++)
  6. if(n%i==0)
  7. {
  8. ans=ans/i*(i-1);
  9. while(n%i==0)n/=i;
  10. }
  11. if(n>1)ans=ans/n*(n-1);
  12. return ans;
  13. } 
int euler_phi(int n)//求单个欧拉函数
{
    int m=(int)sqrt(n+0.5);
    int i,ans=n;
    for(i=2;i<=m;i++)
        if(n%i==0)
        {
            ans=ans/i*(i-1);
            while(n%i==0)n/=i;
        }
    if(n>1)ans=ans/n*(n-1);
    return ans;
}

[cpp] view plain copy print ?
  1. int phi[maxn];
  2. void euler_phi()
  3. {
  4. int i,j,k;
  5. //欧拉函数，phi[i]表示不超过i的与i互质的整数个数
  6. for(i=2;i<maxn;i++)phi[i]=0;
  7. phi[1]=1;
  8. for(i=2;i<maxn;i++)
  9. if(!phi[i])
  10. for(j=i;j<=maxn;j+=i){
  11. if(!phi[j])phi[j]=j;
  12. phi[j]=phi[j]/i*(i-1);
  13. }
  14. } 
int phi[maxn];  
void euler_phi()  
{  
    int i,j,k;  
    //欧拉函数，phi[i]表示不超过i的与i互质的整数个数  
    for(i=2;i<maxn;i++)phi[i]=0;  
    phi[1]=1;  
    for(i=2;i<maxn;i++)  
        if(!phi[i])  
        for(j=i;j<=maxn;j+=i){  
            if(!phi[j])phi[j]=j;  
            phi[j]=phi[j]/i*(i-1);  
        }  
}

8.求三角形两边向量积

，面积S=1/2*|a×b|

[cpp] view plain copy print ?
  1. int cross(node a,node b,node c)//向量积
  2. {
  3. return (a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y);//向量ac×bc
  4. } 
int cross(node a,node b,node c)//向量积
{
    return (a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y);//向量ac×bc
}

9.求凸包

，res数组存凸包上的点。

[cpp] view plain copy print ?
  1. int convex(int n)
  2. {
  3. sort(e,e+n,cmp);//根据x从小到大排序，x相等时根据y从小到大排序
  4. int m=0,i,j,k;
  5. //求得下凸包，逆时针
  6. for(i=0;i<n;i++)
  7. {
  8. while(m>1&&cross(res[m-1],e[i],res[m-2])<=0)m--;
  9. res[m++]=e[i];
  10. }
  11. k=m;
  12. //求得上凸包
  13. for(i=n-2;i>=0;i--)
  14. {
  15. while(m>k&&cross(res[m-1],e[i],res[m-2])<=0)m--;
  16. res[m++]=e[i];
  17. }
  18. if(n>1)m--;//起始点重复。
  19. return m;//返回凸包边界结点数。
  20. } 
int convex(int n)
{
    sort(e,e+n,cmp);//根据x从小到大排序，x相等时根据y从小到大排序
    int m=0,i,j,k;
    //求得下凸包，逆时针
    for(i=0;i<n;i++)
    {
        while(m>1&&cross(res[m-1],e[i],res[m-2])<=0)m--;
        res[m++]=e[i];
    }
    k=m;
    //求得上凸包
    for(i=n-2;i>=0;i--)
    {
        while(m>k&&cross(res[m-1],e[i],res[m-2])<=0)m--;
        res[m++]=e[i];
    }
    if(n>1)m--;//起始点重复。
    return m;//返回凸包边界结点数。
}


10.三分法

[cpp] view plain copy print ?
  1. for(i=0;i<100;i++)
  2. {
  3. m1=l+(r-l)/3;
  4. m2=r-(r-l)/3;
  5. if(find(m1)<find(m2)) r=m2;
  6. else l=m1;
  7. }
NowAndForever
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM数论模板
qq_42024195的博客
05-01 773
取模运算 编程竞赛有相当一部分题目的数据结果过于庞大，往往需要对结果取模。例如(a*b) % p,若a*b的结果存储不了，再去取模，结果显然不对，为了防止溢出，可以分别对a取模,b取模，再求积取模。 取模运算公式： 加法：(a +b) % p = (a%p + b%p) % p 减法：(a - b) % p = ((a%p - b%...
数论模板.zip
12-05
数论是计算机科学中一个重要的理论基础，尤其是在算法竞赛（如ACM）中，数论模板的掌握能够帮助解决问题并优化解题效率。这个"数论模板.zip"压缩包包含了全面的数论知识和相关算法，对于学习和理解数论在编程中的...
数论常用模板
aopeiliao8840的博客
06-09 204
1.埃式筛素数 　　　　 const int maxn=1e6+10; bool isprime[maxn]; int prime[maxn]; int cnt=0; void Prime() { memset(isprime,false,sizeof(isprime)); isprime[0]=isprime[1]=true; for(i...
数论模板~~~持续更新
Nerdant
08-16 192
这份代码是队里数学大佬YZQ的，码风很亲和（逃） 学习一下。 #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll mod=1000007; const ll N=100010; ll v[N],prime[N],phi[N],v1[N],miu[N],m; struct mat {...
数论模板
zxker
09-01 158
gcd，快速幂，原根数 int gcd(int a,int b){ return b?gcd(b,a%b):a;} void init(){ tot = 0;phi[1] = 1; for(int i=2 ;i&lt;A ;i++){ if(!vis[i]){pri[++tot] = i;phi[i] = i-1;} for(int j=1 ;...
数论模板精心整编
07-10
数论模板精心整编，可以一看，以后上传计算几何模板
数论模板-一周时间总结
06-05
自己花费大概两周时间整理，可能不会太全，也可能比较低端，随意看看好了
数论基础算法模板
02-20
数论基础算法模板
数论算法模板
07-21
数学模版,比较实用 适合ACMER打印作为比赛使用模版
数论模板及分析汇总
磊哥哥讲算法
06-29 788
算法编程比赛中的基础数论模板题总结，涉及到了定理的推导和常见模板总结，在理解的过程中背住，在之后的数论问题上会有很大的帮助
数论模板总结
Marcus-Bao的个人主页
09-08 743
1.离散对数 ax≡b(modp)那么x≡loga（b)(modp)a^x \equiv b (mod p ) 那么 x \equiv log_a（b) (mod p) 那么现在我们就来求解这个x. 朴素baby step giant step要求p必须为质数. 整体的复杂度为O(n√)\sqrt n)). //Hash + 扩展欧几里得 +拆分思想 /* 求解模方程a^x=
数论--中国剩余定理模板
日拱一卒,功不唐捐
12-06 2671
void exgcd(int a,int b,int &x,int &y) { if(b==0){ x=1; y=0; return;} exgcd(b,a%b,x,y); int tp=x; x=y; y=tp-a/b*y; } int china() { int ans=0,lcm=1,x,y; for(int i=1;i&lt...
数论常用模板部分整理
满月照亮的路
08-25 280
#pragma comment(linker, "/STACK:102400000,102400000") #include<bits/stdc++.h> using namespace std; #define debug puts("YES"); #define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++) #define lrt ...
NTT简单总结
asd13716936122的博客
08-26 1575
NTT简单总结 NTT是一个玄学的东西，它通过数论达到和FFT一样的效果（甚至还要快得多）。 NTT的原理其实是将FFT的$w^{k}_{n}$通过另外一个东西代替，从而将FFT中极其之慢的（而且精度爆炸的）浮点数运算更改为整数运算。 在讲NTT之前，先来了解一下数学方面的内容。 数学部分 阶 若$(a,p)$=1，且$p>1$，对于$a^{n}\equiv1(mod ...
ACM常用模板-数论
08-29 279
常用数论模板，代码大多数来自网络，个人整理总结，不定期更新 基本函数及其性质： 最大公约数与最小公倍数： gcd： //最大公约数 int gcd(int a,int b) { if(b==0) return a; ...
ACM数论中的常见的模板和结论
weixin_30519071的博客
08-11 173
1:最大公约数的求法 欧几里得算法实现。递归实现 1 #include<stdio.h> 2 #include<string.h> 3 #include<algorithm> 4 #include<iostream> 5 using namespace std; 6 __int64 gcd(__int64 y,__int...
ACM算法与数论模板全面解析
ACM模板是一份专为参加ACM（国际...这份ACM模板提供了扎实的数论、算法、数据结构以及数学工具的基础，对提高ACM竞赛解决问题的能力具有显著作用。参赛者可以根据需要深入学习和应用这些内容，提升编程技能和比赛成绩。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值