数论 - 标签 - 菠菜眾長https://lruihao.cn/tags/%E6%95%B0%E8%AE%BA/数论 - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Fri, 17 May 2019 09:14:16 +0000最大公约数（二进制算法）https://lruihao.cn/posts/gcd-bit/Fri, 17 May 2019 09:14:16 +0000Lruihaohttps://lruihao.cn/posts/gcd-bit/

二进制最大公约数算法避免了欧几里得算法（辗转相除法）的大量取模操作，有效减少了时间消耗，且更为方便。

原理

本算法基于以下事实：

对于两个数的最大公约数 gcd(m, n)，有 m<n 时，gcd(m, n)=gcd(n, m) m 偶 n 偶时，gcd(m, n)=2*gcd(m/2, n/2) m 偶 n 奇时，gcd(m, n)=gcd(m/2, n) m 奇 n 偶时，gcd(m, n)=gcd(m, n/2) m 奇 n 奇时，gcd(m, n)=gcd(n, m-n)

采用递归即可。

实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

inline int GCD(int x,int y)
{
        int i,j;
        if(x==0) return y;
        if(y==0) return x;
        for(i=0;0==(x&1);++i)x>>=1;   // 去掉所有的 2
        for(j=0;0==(y&1);++j)y>>=1;   // 去掉所有的 2
        if(j<i) i=j;
        while(1){
                if(x<y)x^=y,y^=x,x^=y;   // 若 x < y 交换 x, y
                if(0==(x-=y)) return y<<i;  // 若 x == y， gcd == x == y （就是在辗转减，while(1) 控制）
                while(0==(x&1))x>>=1; // 去掉所有的 2
        }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

int get_lcm(int a,int b)///获得最小公倍数
{
    int x=a;
    int y=b;
    while(b)
    {
        int t=a;
        a=b;
        b=t%b;
    }
    return x/a*y;
}
]]>The equation-SGU106（扩展欧几里得）https://lruihao.cn/posts/euclid/Fri, 10 Aug 2018 10:32:39 +0000Lruihaohttps://lruihao.cn/posts/euclid/题意：

给出 a,b,c,x1,x2,y1,y2，求满足 ax+by+c=0，且 x∈[x1,x2],y∈[y1,y2] 的整数解个数。

分析：

对于解二元一次不定方程，容易想到利用扩展欧几里得求出一组可行解后找到通解，下面来介绍一下欧几里得以及扩展欧几里得。

欧几里得：

又名辗转相除法，是用来计算两个数的最大公约数，其中就是利用 gcd(a,b)=gcd(b,a mod b) 来求解。下证 gcd(a,b)=gcd(b,a mod b) 的正确性：

设 a,b 的一个公约数为 d

设 a mod b=r，则 a=kb+r(k 为整数），r=a-kb

因为 d|a,d|b

所以 d|a-kb, 即 d|r，而 r=a mod b

所以 d 为 b,a mod b 的公约数

又因为 d 也为 a,b 的公约数，所以（a,b) 和 (b,a mod b) 的公约数一样，所以最大公约数必然一样，得证。

代码描述：

1
2
3
4
5

int gcd(int a,int b)
{
    if (b==0) return a;
    return gcd(b,a%b);
}

扩展欧几里得

顾名思义，为上述欧几里得算法的扩展。欧几里得是用来求 a,b 的最大公约数，那么扩展欧几里得不仅能求出 a,b 的最大公约数，还能求出满足 ax+by=gcd(a,b) 的一组可行解。
求解过程中，扩展欧几里得比欧几里得多了一个赋值过程，具体证明如下：

设 ax1+by1=gcd(a,b),bx2+(a mod b)y2=gcd(b,a mod b)

因为由欧几里得算法可知，gcd(a,b)=gcd(b,a mod b)

所以 ax1+by1=bx2+(a mod b)y2

因为a mod b=a-(a div b)*b（div 为整除

所以有ax1+by1=bx2+(a-(a div b)*b)y2

将右边移项，展开得：

1
2

ax1+by1=ay2+bx2-(a div b)*b*y2
       =ay2+b[x2-(a div b)]y2

所以可得： x1=y2 y1=x2-(a div b)*y2

将得到的的 x1,y1 递归操作求解 x2,y2，如此循环往复，将会像欧几里得一样得到 b=0 的情况，此时递归结束，返回 x=1,y=0，回溯得解。

代码描述：

此函数返回的是 a,b 的最大公约数，同时也求解出满足 ax+by=gcd(a,b) 的一组可行的 (x,y)

1
2
3
4
5
6
7
8

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

关于求解二元一次不定方程 ax+by=c

首先，如果 c 不是 gcd(a,b) 的倍数，方程显然无解。

扩展欧几里得求解的是 ax+by=gcd(a,b)=1 的可行解，但是题目中并没有说 c 与 a,b 互质之类的条件，所以需要在开始时两边同时除以 gcd(a,b)。

设 d=gcd(a,b)

设 a’=a/d,b’=b/d,c’=c/d,

则下面需要求解 a’x+b’y=c’的整数解，而 gcd(a’,b’)=1，

则我们只需求 a’x+b’y=1 的可行解

直接使用扩展欧几里得，得到 (x’,y’), 则最终解为x'*c',y'*c'设为 (x0,y0)。

现在得到了一组可行解，但是如何得到通解呢？

将 (x0,y0) 代入 ax+by=c，则有

a*(x0)+b*(y0)=c

通过拆添项，可有：

1
2
3
4
5
6
7

a*(x0+1*b)+b*(y0-1*a)=c

a*(x0+2*b)+b*(y0-2*a)=c

a*(x0+3*b)+b*(y0-3*a)=c

……

a*(x0+k*b)+b*(y0-k*a)=c (k∈Z)

至此，我们得到了通解的方程

x=x0+k*b y=y0-k*a (k∈Z)

这样，所有满足 ax+by=c 的可行解都可求出。

具体实现

有了主体算法，下面要谈到具体实现了。

先处理一下无解的情况：

  1. 当 a=0 并且 b=0，而 c≠0 时，显然无解；
    当 a=0,b=0，而 c=0 时，[x1,x2],[y1,y2] 都为可行解，根据乘法原理，可行解的个数为(x2-x1+1)*(y2-y1+1);

  2. 当 a=0 b≠0 时：
    此时即为求解 by=c，则 y=c/b，
    如果 c/b 不是整数或 c/b 不在 [y1,y2] 的范围内，无解
    否则 [x1,x2] 内全部整数都为可行解。

  3. 当 b=0,a≠0 时，同上。

  4. 若 c 不是 gcd(a,b) 的个数，方程显然无解。

处理完了一些繁琐的细节后，下面是具体的求解过程：

  1. 扩展欧几里得求解的是 ax+by=c，而本题是 ax+by+c=0，需将 c 移项。

  2. 对于本道题，首先要注意的是，对于负数的模运算在此算法中无法得到正确解，所以要处理一下 a,b,c 的正负情况。 如果 a 为负数，只需将 a 取相反数后，再处理一下 x∈[x1,x2] 的范围。当 a 取了相反数，相当于把 x 也取反，则需要把 x 的范围由 [x1,x2] 转变成 [-x2,-x1], 类似于把数轴反了过来。b 同理。

  3. 利用扩展欧几里得解二元一次不定方程，得到一组可行解 (x0,y0)。

  4. 因为题目中对 x,y 有条件约束，而有 x=x0+kb,y=y0-kb，我们可以求出满足 x∈[x1,x2],y∈[y1,y2] 的 k 的取值范围， 即为求解 x1<=x0+kb<=x2,y1<=y0-kb<=y2 的整数 k 的个数 但是在求解这两个一次函数的过程中，会有除不尽的现象，该如何取整呢？

举个例子

当出现 2.5<=k<=5.5 时，我们需要的可行的 k 为 3,4,5，所以需要将 2.5 向上取整得到 3，5.5 向下取整得到 5，即为 3<=k<=5；

当出现-5.5<=<=-2.5 时，我们需要的可行的 k 为-5,-4,-3, 所以需要将-5.5 向上取整得到-5,-2.5 向下取整得到-3，即为-5<=k<=-3；

正负数的情况都已经考虑完全了，可以得到取整的结论：上界下取整，下界上取整。

最后，将得到的两个范围取交集，得到 [l,r]，则最终答案为 r-l+1。

这样，本题就可以完美解决了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// BY Rinyo

#include<cstdio>
#include<cmath>
long long a,b,c,x1,x2,yy1,y2,x0,yy0;
inline long long cmin(const long long &x,const long long &y) {return x<y?x:y;}
inline long long cmax(const long long &x,const long long &y) {return x>y?x:y;}

long long gcd(long long a,long long b)
{
    if (b==0) return a;
    return gcd(b,a % b);
}
void exgcd(long long a,long long b)
{
    if (b==0){x0=1;yy0=0;return;}
    exgcd(b,a%b);
    long long t=x0;x0=yy0;yy0=t-a/b*yy0;
    return;
}

int main()
{
    scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&x1,&x2,&yy1,&y2);
    c=-c;
    if (c<0) {a=-a;b=-b;c=-c;}
    if (a<0) {a=-a;long long t=x1;x1=-x2;x2=-t;}
    if (b<0) {b=-b;long long t=yy1;yy1=-y2;y2=-t;}
    if (a==0 && b==0)
    {
        if (c==0)
        {
            printf("%I64d",(x2-x1+1)*(y2-yy1+1));
            return 0;
        }
        printf("0");return 0;
    }
    else if (a==0)
    {
        if (c %b ==0)
            if (c/b<=y2 && c/b>=yy1) {printf("%I64d",x2-x1+1);return 0;}
        printf("0");return 0;
    }
    else if (b==0)
    {
        if (c%a==0)
            if (c/a<=x2 && c/a>=x1) {printf("%I64d",y2-yy1+1);return 0;}
        printf("0");return 0;
    }

    long long d=gcd(a,b);
    if (c%d!=0){printf("0");return 0;}

    a=a/d;b=b/d;c=c/d;
    exgcd(a,b);
    x0=x0*c;yy0=yy0*c;

    double tx2=x2,tx1=x1,tx0=x0,ta=a,tb=b,tc=c,ty1=yy1,ty2=y2,ty0=yy0;
    long long down1=floor(((tx2-tx0)/tb)),down2=floor(((ty0-ty1)/ta));
    long long r=cmin(down1,down2);
    long long up1=ceil(((tx1-tx0)/tb)),up2=ceil(((ty0-ty2)/ta));
    long long l=cmax(up1,up2);
    if (r<l) printf("0");
    else printf("%I64d",r-l+1);
    return 0;

}

扩展欧几里得模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include<iostream>
using namespace std;

int exgcd(int a,int b,int &x,int &y)
{
     if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    int gcd=exgcd(b,a%b,x,y);
    int x2=x,y2=y;
    x=y2;
    y=x2-(a/b)*y2;
    return gcd;
}

int main()
{
int x,y,a,b;
cout<<"请输入 a 和 b:"<<endl;
cin>>a>>b;
cout<<"a 和 b 的最大公约数："<<endl;
cout<<exgcd(a,b,x,y)<<endl;
cout<<"ax+by=gcd(a,b) 的一组解是："<<endl;
cout<<x<<" "<<y<<endl;
return 0;
}
]]>Leading and Trailing-lightoj1282（快速幂+对数运算）https://lruihao.cn/posts/lightoj1282/Thu, 09 Aug 2018 20:55:26 +0000Lruihaohttps://lruihao.cn/posts/lightoj1282/题目链接

题目大意：

给定两个数 n,k 求 n^k 的前三位和最后三位。

分析

求后三位的话：直接快速幂，对 1000 取模就好了。
求前三位，对于给定的一个数 n, 它可以写成 n=10^a, 其中这个 a 为浮点数，则t=n^k=(10^a)^k=10^a*k=(10^x)*(10^y);其中 x,y 分别是a*k的整数部分和小数部分，对于 t=n^k 这个数，它的位数由 (10^x) 决定，它的位数上的值则有 (10^y) 决定，因此我们要求 t 的前三位，只需要将 10^y 求出，在乘以 100，就得到了它的前三位。
分析完，我们再整体看，设 n^k=10^z; 那么z=k*log10(n)
fmod(z,1)可以求出 x 的小数部分。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

//再一次吐槽 lightoj 的头文件，让我不能用万能头<bits/stdc++.h>
#include<stdio.h>
#include<math.h>

typedef long long LL;

int quickpow (int m, int n, int k)
{
    int b = 1;
    while (n > 0)
    {
        if (n & 1)
            b = (b * m) % k;
        n >>= 1;
        m = (m * m) % k;
    }
    return b%k;
}

int main ()
{
    int t, flag = 1;
    scanf ("%d", &t);

    while (t--)
    {
        LL n, k;
        scanf ("%lld %lld", &n, &k);

        int first = pow (10.0, 2.0 + fmod (k*log10(n*1.0), 1));
        int last = quickpow (n%1000, k, 1000);

        printf ("Case %d: %d %03d\n", flag++, first, last);
    }
    return 0;
}

注：

C 库函数 - fmod()
C 库函数 double fmod(double x, double y) 返回 x 除以 y 的余数。

  • x – 代表分子的浮点值。
  • y – 代表分母的浮点值。 该函数返回 x/y 的余数。

下面的实例演示了 fmod() 函数的用法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <stdio.h>
#include <math.h>

int main ()
{
   float a, b;
   int c;
   a = 9.2;
   b = 3.7;
   c = 2;
   printf("%f / %d 的余数是 %lf\n", a, c, fmod(a,c));
   printf("%f / %f 的余数是 %lf\n", a, b, fmod(a,b));

   return(0);
}

结果：

9.200000 / 2 的余数是 1.200000
9.200000 / 3.700000 的余数是 1.800000
]]>欧拉函数https://lruihao.cn/posts/euler/Wed, 08 Aug 2018 17:10:07 +0000Lruihaohttps://lruihao.cn/posts/euler/欧拉函数是求小于 x 并且和 x互质 的数的个数

通式：φ(x)=x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn)
其中 p1, p2……pn 为 x 的所有质因数，x 是不为 0 的整数
φ(1)=1（唯一和 1 互质的数就是 1 本身）【注意：每种质因数只一个。比如 12=223】

定理：

  1. 若 n 是素数 p 的 k 次幂，φ(n)=p^k-p^(k-1)=(p-1)p^(k-1)，因为除了 p 的倍数外，其他数都跟 n 互质
  2. 欧拉函数是积性函数——若 m,n 互质，φ(mn)=φ(m)φ(n)

特殊性质：

  1. 当 n 为奇数时，φ(2n)=φ(n)
  2. p 是素数，φ(p) = p - 1，φ(p) 称为 p 的欧拉值
  3. 若 a 为素数，b mod a=0,φ(a*b)=φ(b)*a

模板

//直接法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

int Euler(int n){
	int res = n,i;

 	//由于任何一个合数都至少有一个不大于根号 n 的素因子，所以只要遍历到根号 n 即可
	for(i=2;i * i <= n;i++)
	if(n%i == 0){  //第一次找到的必为素因子
		n /=i ;
		res = res - res/i;	//x(1-1/p1)
		while(n % i ==0)
			n/=i;  //将该素因子的倍数也全部筛掉
	}

	if (n > 1)
        res = res - res/n;
   	return res;
}

以上转载注明

//素数筛选法，先素数筛选，再求欧拉

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/*
特性 :
1. 若 a 为质数，phi[a]=a-1;
2. 若 a 为质数，b mod a=0,phi[a*b]=phi[b]*a
3. 若 a,b 互质，phi[a*b]=phi[a]*phi[b](当 a 为质数时，if b mod a!=0 ,phi[a*b]=phi[a]*phi[b])
*/
int m[n],phi[n],p[n],nump;
//m[i] 标记 i 是否为素数，0 为素数，1 不为素数；p 是存放素数的数组；nump 是当前素数个数；phi[i] 为欧拉函数
int make()
{
        phi[1]=1;
    for (int i=2;i<=n;i++)
    {
        if (!m[i])//i 为素数，m[] 初始化为 0
        {
            p[++nump]=i;//将 i 加入素数数组 p 中
            phi[i]=i-1;//因为 i 是素数，由特性得知
        }
        for (int j=1;j<=nump&&p[j]*i<n;j++)  //用当前已的到的素数数组 p 筛，筛去 p[j]*i
        {
            m[p[j]*i]=1;//可以确定 i*p[j] 不是素数
            if (i%p[j]==0) //看 p[j] 是否是 i 的约数，因为素数 p[j], 等于判断 i 和 p[j] 是否互质
            {
                phi[p[j]*i]=phi[i]*p[j]; //特性 2
                break;
            }
            else phi[p[j]*i]=phi[i]*(p[j]-1); //互质，特性 3,p[j]-1 就是 phi[p[j]]
        }
    }
}

附素数打表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int  p[N]={1,1,0};

void prime(){
	for(int i=2;i<N;i++)
		if(!p[i]){
			for(int j=2*i;j<=N;j+=i)//筛掉 i 的倍数
				p[j]=1;
		}

}

例题

Bi-shoe and Phi-shoe LightOJ - 1370

题意：
给一些数 Ai（第 i 个数），Ai 这些数代表的是某个数欧拉函数的值，我们要求出数 Ni 的欧拉函数值不小于 Ai。而我们要求的就是这些 Ni 这些数字的和 sum，而且我们想要 sum 最小，求出 sum 最小多少。

解题思路：
要求和最小，我们可以让每个数都尽量小，那么我们最后得到的肯定就是一个最小值。
给定一个数的欧拉函数值 ψ(N)，我们怎么样才能求得最小的 N?
我们知道，一个素数 P 的欧拉函数值 ψ(P)=P-1。所以如果我们知道 ψ(N)，那么最小的 N 就是最接近 ψ(N)，并且大于 ψ(N) 的素数。我们把所有素数打表之后再判断就可以了。

这个 lightoj 有毒，什么头文件都不支持，卡了我好久。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include<stdio.h>
#define N 1000005
#define ll long long

int m[N]={1,1,0};
int p[100000],cnt=0;

int max(int x,int y){
    return x>y?x:y;
}

void prime(){
    for(int i=2;i<N;i++)
    if(!m[i]){
        for(int j=2*i;j<=N;j+=i)
            m[j]=1;
        p[cnt++]=i;
    }
}

int binary_search(int x){//二分查找
    int l=0,r=cnt;
    while(l<=r){
        int mid=(l+r)/2;
        if(p[mid]>x)
            r=mid-1;
        else l=mid+1;
    }
    for(int i=max(r,0);;i++)
        if(p[i]>x)
        return p[i];
}

int main(){
    prime();
    int T,n,cas=1,temp;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        ll sum=0;
        for(int i=0;i<n;i++){
            scanf("%d",&temp);
            sum+=binary_search(temp);
        }
        printf("Case %d: %lld Xukha\n",cas++,sum);
    }
	return 0;
}
]]>