2023寒假算法学习11 数论

欧几里得算法——转转相除法

（a,b）=（b,a mod b）

算术基本定理

每一个数都能分解成若干个质因子的乘积

筛分求素数

线性筛法 O(n) 求1~n中所有的指数，以及每一个数的最小质因子

筛掉的是合数，且用其最小质因子筛的

#include<cstdio>
#include<iostream>

using namespace std;

const int N=1000010;
int primes[N],cnt;//存所有质数
bool st[N];//当前数有没有被筛过
//st[5]==false 表示没有被筛过
//st[5]==true 表示被筛过 被筛过表示它是某一个数的倍数
int get_primes(int n)//O(n)
{
    for(int i=2;i<=n;i++)
    {
        if(!st[i]) primes[cnt++]=i;//没有被筛过，没有质因子，就是质数
        for(int j=0;primes[j]*i<=n;j++)//从小到大枚举所有的质数，把这个质数的i倍筛掉
        {
            st[primes[j]*i]=true;
            if(i%primes[j]==0) break;//不超过primes还没更新的地方
        }
    }
}

int main()
{
    get_primes(100000);
    for(int i=0;i<20;i++)
    printf("%d\n",primes[i]);
    return 0;
}

约数个数/约数之和

12=2^2*3 约数个数是6

12的约数之和：（1+2+2^2）*(1+3)=28

裴蜀定理——扩展欧几里得算法

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

int exgcd(int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x=1,y=0;
        return a;
    }
    int d=exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}
int main()
{
   int a,b,x,y;
   cin>>a>>b;
   int d=exgcd(a,b,x,y);
   printf("%d * %d + %d * %d = %d\n",a,x,b,y,d);
   
   return 0;
}

求一个数模n的最小非负数

 res=(res%n+n)%n;

AcWing 1246 等差数列

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int N=100005;
int a[N],b[N];

int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    sort(a,a+n);
    for(int i=1;i<n;i++) b[i]=a[i]-a[i-1];
    sort(b+1,b+n);
    //for(int i=1;i<n;i++)
    //cout<<b[i]<<endl;
    int min=gcd(b[1],b[2]);
    for(int i=2;i<n-1;i++)
    {
        if((gcd(b[i],b[i+1]))<min) min=gcd(b[i],b[i+1]);
    }
    if(min==0) cout<<n;
    else
    {
        int res=(a[n-1]-a[0])/min+1;
        cout<<res;
    }
    return 0;
}

AcWing 1295 x的因子链

有多行输入

#include<cstdio>
#include<iostream>

using namespace std;

const int N=(1<<20)+10;
int primes[N],cnt;
int minp[N];//最小质因子
bool st[N];

void get_primes(int n)
{
    for(int i=2;i<n;i++)
    {
        if(!st[i]) 
        {
            primes[cnt++]=i;
            minp[i]=i;
        }
        for(int j=0;primes[j]*i<=n;j++)
        {
            st[primes[j]*i]=true;
            minp[primes[j]*i]=primes[j];
            if(i*primes[j]==0) break;
        }
    
    }
}
int main()
{
    get_primes(N-1);//用线筛法求一下1到n-1内所有的质因子
    int x;
    int fact[30];//所有质因子的个数，全是2的话最多是20
    int sum[30];//因子个数
    while(scanf("%d",&x)!=EOF)
    {
        int k=0;
        int total=0;
        while(x>1)
        {
            int p=minp[x];
            fact[k]=p,sum[k]=0;
            while(x%p==0)
            {
                x/=p;
                sum[k]++;
                total++;
            }
            k++;
        }
        long long res=1;
        for(int i=1;i<=total;i++) res*=i;
        for(int i=0;i<k;i++)
        {
            for(int j=1;j<=sum[i];j++)
            res/=j;
        }
        printf("%d %d\n",total,res);
    }
    return 0;
}

AcWing 1296 聪明的燕姿

枚举p和α

剪枝：α=1的时候特判，判断S-1是不是质数。只要不是这种形式，就要在枚举p的时候满足p*p<s，只用枚举到根号S

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

using namespace std;

const int N=50000;
int primes[N],cnt;
bool st[N];

int ans[N];//记录答案
int len;//答案个数
void get_primes(int n)
{
    for(int i=2;i<=n;i++)
    {
        if(!st[i]) primes[cnt++]=i;
        for(int j=0;primes[j]*i<=n;j++)
        {
            st[primes[j]*i]=true;
            if(i%primes[j]==0) break;
        }
    }
}
bool is_primes(int x)
{
    if(x<N) return !st[x];
    for(int i=0;primes[i]<=x/primes[i];i++)
    if(x%primes[i]==0)
    return false;
    return true;
    
}

void dfs(int last,int prod,int s)//上一个用到的质数下标是多少，要求的答案数是多少，s是剩余的s是多少
{
    //printf("prod:%d\n",prod);
    if(s==1) //说明已经把s的形式凑出来了
    {
        ans[len++]=prod;
        return;
    }
    if(s-1>(last<0?1:primes[last])&&is_primes(s-1))//起码是2否则是上一个质数
    {
        ans[len++]=prod*(s-1);
    }
    for(int i=last+1;primes[i]<=s/primes[i];i++)
    {
        int p=primes[i];
        for(int j=p+1,t=p;j<=s;t*=p,j+=t)//t存每一项的最大次幂，j存每一项的和
        {
            if(s%j==0)
            //printf("dfs(i,prod*t,s/j)%d %d %d\n",i,prod*t,s/j);
            dfs(i,prod*t,s/j);
        }
    }
}
int main()
{
    get_primes(N-1);
    int s;
    while(scanf("%d",&s)!=EOF)
    {
        len=0;
        dfs(-1,1,s);
        // for(int i=0;i<len;i++)
        //     printf("%d ",ans[i]);
        //     printf("\n");
        cout<<len<<endl;
        if(len)
        {
            sort(ans,ans+len);
            for(int i=0;i<len;i++)
            printf("%d ",ans[i]);
            printf("\n");
        }
    }
    return 0;
}

AcWing 1299 五指山

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

typedef long long ll;

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

int main()
{
    int t;
    cin>>t;
    ll n,d,x,y;
    ll a,b;
    while(t--)
    {
        scanf("%lld%lld%lld%lld",&n,&d,&x,&y);
        ll r=exgcd(d,n,a,b);
        //printf("%d * %d + %d * %d = %d\n",d,a,n,b,r);
        if((y-x)%r!=0) printf("Impossible\n");
        else
        {
            ll res=(y-x)*a/r;
            n=n/r;
            res=(res%n+n)%n;
            printf("%lld\n",res);//关于模不要带绝对值，正负模的绝对值不同
            // a*=(y-x)/r;
            // n/=r;
            // printf("%d\n",(a%n+n)%n);//关于模不要带绝对值，正负模的绝对值不同
        }
    }
   return 0;
}

AcWing 1223 最大比例

辗转相减法

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int N=105;
long long x[N],a[N],b[N];
long long gcd(long long a,long long b)
{
    return b==0? a: gcd(b,a%b);
}
long long gcd_sub(long long a,long long b)
{
    if(a<b) swap(a,b);
    if(b==1) return a;
    return gcd_sub(b,a/b);
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++) cin>>x[i];
    sort(x,x+n);
    
    int cnt=0;
    for(int i=1;i<n;i++)
    {
        if(x[i]!=x[i-1])
        {
            long long d=gcd(x[i],x[0]);
            a[cnt]=x[i]/d;
            b[cnt]=x[0]/d;
            cnt++;
        }
    }
    //辗转相减法
    long long up=a[0],down=b[0];
    for(int i=1;i<cnt;i++)
    {
        cout<<a[i]<<' '<<b[i]<<endl;
        up=gcd_sub(up,a[i]);
        down=gcd_sub(down,b[i]);
    }
    cout<<up<<'/'<<down;
    return 0;
}

AcWing 1301 C循环

k位系统：所有的变量都只能存最后k位

long long 类型的2^k

ll z=1ll<<k;

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

typedef long long ll;

ll exgcd(ll a,ll b,ll &x,ll &y)
{
    if(b==0)
    {
        x=1,y=0;
        return a;
    }
    ll d=exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}
int main()
{
    ll a,b,c,k;
    ll x,y;
    while(cin>>a>>b>>c>>k,a||b||c||k)
    {
        ll z=1ll<<k;
        ll gcd=exgcd(c,z,x,y);
        if((b-a)%gcd) printf("FOREVER\n");
        else
        {
            x*=(b-a)/gcd;
            z/=gcd;
            printf("%lld\n",(x%z+z)%z);
        }
    }
}