数论总结1

最新推荐文章于 2022-09-27 08:53:44 发布

kikiss_

最新推荐文章于 2022-09-27 08:53:44 发布

阅读量259

点赞数 1

分类专栏：【数学】 ———初等数论【算法总结】

本文链接：https://blog.csdn.net/qq_34845082/article/details/77971408

版权

【数学】同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

———初等数论

2 篇文章 0 订阅

订阅专栏

【算法总结】

1 篇文章 0 订阅

订阅专栏

数论总结1

欧几里德

欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。

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

扩展欧几里德

ll exgcd(ll a,ll b,ll&x,ll&y){
   if(b==0){
       x=1;
       y=0;
       return a;
    }
   ll r=exgcd(b,a%b,x,y);
   ll t=x;
   x=y;
   y=t-a/b*y;
   return r;
}

求解形如ax+by=c的方程

Ø 结论：设a, b, c为任意整数，g=gcd(a,b)，方程ax+by=g的一组解是(x0,y0)，则当c是g的倍数时，ax+by=c的一组解是(x0c/g, y0c/g)；当c不是g的倍数时ax+by=c无整数解。

Ø 调用函数exgcd(a,b,x,y)之后，x,y是ax+by=g的一组解

POJ 1061 青蛙的约会

/* 
*输入x、y、m、n、L
*解方程(n-m)*k + L*s = x-y，求k的最小非负解
*/
#include<cmath>
#include<vector>
#include<cstdio>
#include<string>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
ll X,Y,m,n,l,x,y,mul,g;
ll gcd(ll a,ll b){
   if(b==0)
       return a;
   return
       gcd(b,a%b);
}
ll exgcd(ll a,ll b,ll&x,ll&y){
   if(b==0){
       x=1;
       y=0;
       return a;
    }
   ll r=exgcd(b,a%b,x,y);
   ll t=x;
   x=y;
   y=t-a/b*y;
   return r;
}
//用扩展欧几里得算法解不定方程ax+by=c
bool linear_equation(ll a,ll b,llc,ll&x,ll&y){
   ll d=exgcd(a,b,x,y);
   ll A=a/g,B=b/g;
   x=((x*mul)%B+B)%B;
   return true;
}
int main(){
   while(~scanf("%lld%lld%lld%lld%lld",&X,&Y,&m,&n,&l)){
       g=gcd(n-m,l);
       if((X-Y)%g!=0){
           printf("Impossible\n");
       }
       else{
           mul=(X-Y)/g;
           linear_equation(n-m,l,X-Y,x,y);
           printf("%lld\n",x);
       }
    }
   return 0;
}

埃筛

/* 
*素数筛选，存在小于等于MAXN的素数
* prime[0]存的是素数的个数 
*时间复杂度O(nloglogn)
*/
const int MAXN=10010;
int prime[MAXN+5];
void getprime(){
   memset(prime,0,sizeof(prime));
   for(int i=2;i<=MAXN;i++){
       if (!prime[i])
           prime[++prime[0]]=i;
       for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++){
           prime[prime[j]*i]=1;
           if(i%prime[j] ==0) break;
       }
    }
}

大区间素数筛

/*
* POJ 2689 PrimeDistance
*给出一个区间[L,U]，找出区间内相邻的距离最近的两个素数以及
*距离最远的两个素数
*1<=L<U<=2,147,483,647，区间长度不超过1,000,000
*就是要筛选出[L,U]间的素数
*最大区间太大（1~2,147,483,647），不能筛出该区间内的素数
*因此先筛出2~sqrt(MAX)，再用这张素数表筛出区间内素数
*/
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
using namespace std;
const int MAXN=100010;
int prime[MAXN+1];
void getPrime(){
   memset(prime,0,sizeof(prime));
   for(int i=2;i<=MAXN;i++){
       if(!prime[i])
           prime[++prime[0]]=i;
       for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++){
           prime[prime[j]*i]=1;
           if(i%prime[j]==0)break;
       }
    }
}
bool notprime[1000010];
int prime2[1000010];
void getPrime2(int L,int R){
   memset(notprime,false,sizeof(notprime));
   if(L<2)
       L=2;
   for(int i=1;i<=prime[0]&&(longlong)prime[i]*prime[i]<=R;i++){
       int s=L/prime[i]+(L%prime[i]>0);
       if(s==1)
           s=2;
       for(int j=s;(long long)j*prime[i]<=R;j++)
           if((long long)j*prime[i]>=L)
                notprime[j*prime[i]-L]=true;
    }
   prime2[0]=0;
   for(int i=0;i<=R-L;i++)
       if(!notprime[i])
           prime2[++prime2[0]]=i+L;
}
int main(){
   getPrime();
   int L,U;
   while(scanf("%d%d",&L,&U)==2){
       getPrime2(L,U);
       if(prime2[0]<2)
           printf("There are no adjacent primes.\n");
       else{
           int x1=0,x2=100000000,y1=0,y2=0;
           for(int i=1; i<prime2[0]; i++){
               if(prime2[i+1]-prime2[i]<x2-x1){
                   x1=prime2[i];
                    x2=prime2[i+1];
                }
               if(prime2[i+1]-prime2[i]>y2-y1){
                    y1=prime2[i];
                    y2=prime2[i+1];
                }
           }
           printf("%d,%d are closest, %d,%d are mostdistant.\n",x1,x2,y1,y2);
       }
    }
}

唯一分解定理

Ø 任何大于１的自然数，都可以唯一分解成有限个质数的乘积

例如对于大于1的自然数n，

这里Pi均为质数，其指数ai是正整数。
这样的分解称为的标准分解式。

Ø 唯一分解定理具有：①唯一性（分配方式的唯一性） ②存在性

Ø 定理应用

（1）一个大于1的正整数N，如果它的标准分解式为：

，那么它的正因数个数为

。

（2）它的全体正因数之和为

。当

时就称N为完全数。是否存在奇完全数，是一个至今未解决之猜想。

（3）利用算术基本定理可以重新定义整数a和b的最大公因子和最小公倍数，并证明。

（4）此外还可证明根号2是无理数等等。

（5）证明素数个数无限。

素数筛选+合数分解(标准分解式)

const int MAXN=10010;
int prime[MAXN+5];
void getprime(){
   memset(prime,0,sizeof(prime));
   for(int i=2;i<=MAXN;i++){
       if (!prime[i])
           prime[++prime[0]]=i;
       for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++){
           prime[prime[j]*i]=1;
           if(i%prime[j] ==0) break;
       }
    }
}
long long factor[100][2];
int fatCnt;
int getFactors(long long x){
//分解x
   fatCnt=0;
   long long tmp=x;
for(inti=1;prime[i]<=tmp/prime[i];i++){
//prime[i]<=sqrt(tmp)
       factor[fatCnt][1]=0;
       if(tmp%prime[i]==0){
           factor[fatCnt][0]=prime[i];
           while(tmp%prime[i]==0){
                factor[fatCnt][1]++;
                tmp/=prime[i];
                //一直除，找到prime[i]的幂值
           }
           fatCnt++;
       }
    }
   if (tmp != 1){
       factor[fatCnt][0] = tmp;
       factor[fatCnt++][1] = 1;
    }
   return fatCnt;
}
//测试用main函数：
int main(){
   getprime();
   long long num;
   while(cin>>num){
       printf("%d\n",getFactors(num));//标准分解式中质数项个数
       for(int i =0; factor[i][0]&&factor[i][1]; i++)
           cout<<factor[i][0]<<""<<factor[i][1]<<endl;
            //质数、该质数在标准分解式中的指数
       cout<<endl;
    }
   return 0;
}

HDU 6069 Counting Divisors

* HDU 6069

* d(n)代表n的因子个数，要求：

(\sum i = l r d (i k)) mod 998244353

l,r,k(1≤l≤r≤1012,r−l≤106,1≤k≤107)

*枚举不超过sqrt(10^12)所有质数p

*再枚举区间[l,r]中所有p的倍数，将其分解质因数

*剩下不能分解的数是大素数

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<map>
#include<set>
#include<queue>
using namespace std;
#define mod 998244353
long long sum[maxn],a[maxn];
#define maxn 1000009
int cnt;
bool Isprime[maxn];
long long prime[maxn];
void getPrime(){
   cnt=0;
   memset(Isprime,true,sizeof(Isprime));
   Isprime[1]=false;
   for(int i=2;i<maxn;i++){
       if(Isprime[i]){
           prime[cnt++]=i;
           for(int j=2;i*j<maxn;j++)
               Isprime[i*j]=false;
       }
    }
}
int main(){
   getPrime();
   int T;
   cin>>T;
   long long l,r,k;
   while(T--){
       cin>>l>>r>>k;
       for(int i=0;i<=r-l;i++){
           a[i]=i+l;
           sum[i]=1;
       }
       long long limit=sqrt(r+0.5);
       for(int i=0;i<cnt&&prime[i]<=limit;i++){
           long long f=(l/prime[i]+(l%prime[i]?1:0))*prime[i];//第一个能整除prime[i]的数
           for(long long j=f;j<=r;j+=prime[i]){
               //每个j都能整除prime[i]
               long long num=0;
               while(a[j-l]%prime[i]==0){
                   a[j-l]/=prime[i];
                   num++;
               }//一直除,找到prime[i]的幂值
               sum[j-l]=(sum[j-l]*((num*k+1)%mod))%mod;
               //cout<<sum[j-l]<<endl;
           }
       }
       long long ans=0;
       for(int i=0;i<=r-l;i++){
           if(a[i]!=1)
               sum[i]=(sum[i]*(k+1))%mod;//素数
           ans=(ans+sum[i])%mod;
       }
       printf("%lld\n",ans);
    }
    return0;
}

kikiss_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数论总结1

数论总结1欧几里德欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。ll gcd(ll a,ll b){ return b?gcd(b,a%b):a;}扩展欧几里德ll exgcd(ll a,ll b,ll&amp;x,ll&amp;y){ if(b==0){ x=1; y=0; return a; } ll r=...
复制链接

扫一扫

专栏目录