数论的笔记

数论

再次声明这只是本人整理的学习笔记，只是为了和我一样在学习的萌新分享一下学习的资料，若有重复的地方实属正常，同时没有转载只是因为自己多了一些批注的地方。(●'◡'●)

1、求最大不能组合数

已知两个数，求两个数字不能够被组合出的最大数字

例如：4和7的最大不能组合数是17

公式：a*b-a-b

[homework_detail_problem - 历届试题 带分数 - 追梦算法网]:

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    cout<<n*m-n-m<<endl;//带入公式
    return 0;
}

2、同余定理

给定一个正整数m，如果两个整数a和b满足a-b能够被m整除，即(a-b)/m得到一个整数，那么就称整数a与b对模m同余，记作a≡b(mod m)。对模m同余是整数的一个等价关系。

例题：Problem Detail - Fibonacci数列 - 追梦算法网斐波拉契问题

公式**：**（a+b) mod n=((a mod n) + (b mod n)) mod n

(a-b) mod n=((a mod n) - (b mod n)) mod n

(a✖b) mod n=((a mod n) ✖ (b mod n)) mod n

除法是没有取余的！！！！

3、最大公约数（GCD)

定义： 最大公因数，也称最大公约数、最大公因子，指两个或多个整数共有约数中最大的一个。

一定注意左边的数字是大于右边的数字的！！！！

//有两种方法
//第一种：更相减损法
int way1(int a,int b){
    if(a==0){
        return b;
    }
    if(b==0){
        return a; 
    }
    if(a==b){
        return a;
    }
    if(a>b){
        return way1(a-b,b);
    }
    if(a<b){
        return way1(a,b-a);
    }
}
​
//第二种方法：辗转相除法
int way2(int a,int b){
    while(b>0){
        int t=a%b;
        a=b;
        b=t;
    }
    return a;
}

4、最小公倍数 (LCM)

定义： 最小公倍数是一种数学概念，是指两个或多个整数公有的倍数中，除0以外最小的一个公倍数 。

公式：（）

5、拓展欧几里得定理

应用：求解方程的解。

例子：求解任意一组解：ax+by=1

int way(int a,int b,int &x,int &y)//返回的值还是GCD(a,b)
{
    if(b==0)//等于0的情况直接返回了
    {
        x=1;
        y=0;
        return a;
    }
    int ans=way(b,a%b,x,y);//获得x',y';
    int temp=x;//存储x'
    x=y;//x=y'
    y=temp-(a/b)*x;//y=x'-(a/b)*y'
    return ans;
}
​

6、唯一分解定理

定义： 正整数的唯一分解定理，即：每个大于1的自然数均可写为质数的积，而且这些素因子按大小排列之后，写法仅有一种方式。

例题：不限制输入的数的个数，求每一个数被分解的结果，每个数的结果为单独的一行

#include <bits/stdc++.h>
using namespace std;
int main(){
    long n,i;
    while(~scanf("%d",&n))
    {
        i=1;
        while(n>=i*i)//也可以用n开方来和i进行比较
        {
            i++;
            while(n%i==0)//循环是看是否有两个一样的数字，比如6就可以分解为2，2，3
            {
                printf("%ld",i);
                n/=i;
            }
        }
        if(n!=1){//还要判断最后剩下的数字是否需要输出！！！！
            printf("%ld",n);
        }
    }
}

7、素数三大筛

（1）朴素素数筛

原理：用循环直接遍历到一个数字A的根号下A

bool isprime(int a){
    if(a==0||a==1){
        return false;
    }else{
        for(int i=2;a>=i*i;i++){
            if(a%i==0){
                return false;
            }
        }
        return true;
    }
    
}

（2）埃式筛

原理：对已知的质数进行加倍操作，得到的加倍后的数都是合数。这样通过筛选可以得到N范围以内的质数，但是复杂程度比较高，因为筛选过程中会出现重复筛选。

代码如下：

#include <bits/stdc++.h>
using namespace std;
​
const int N =10000005;
bool vis[N];//需要开一个视图，来看看是否用过了！！！！
​
int main()
{
memset(vis,false,sizeof(vis));//初始化全部为false
int n,x;
for(int i=2;i*i<=N;i++){
    if(!vis[i]){
        for(int j=i*2;j<=N;j+=i){//但是会出现重复的判断的现象，提高了复杂度
            vis[j]=true;
        }
    }
}
while(~scanf("%d",&x)){//输入一个数检验他是否是素数
    if(vis[x]){
        printf("No");
    }
    else{
        printf("Yes");
    }
}
return 0;
}

（3）欧拉筛

原理：和埃式筛很像，但是复杂都没有其高

任何合数都能表示成多个素数的积。所以，任何的合数肯定有一个最小质因子。我们通过这个最小质因子就可以判断什么时候不用继续筛下去了

暂时还没有搞懂，只有后来来康康了。😭

（4）米勒罗宾

检验较大的质数

8、矩阵运算

（1）矩阵的加减法

直接对应位置进行运算

（2）矩阵的乘法

矩阵乘法就是A矩阵的第i行和B矩阵的第j列进行乘法运算，并作为结果矩阵C的C [i] [j]元素

#include <bits/stdc++.h>
using namespace std;
#define N 100;
struct node{
    int n,m;
    int mp[N][N];
    void init(int n,int m){
        this->n=n;//不是很懂！！！！
        this->m=m;
    }
};
//加法
M add(M L,M R){
    if(L.n!=L.n||L.m!=R.m){
        return L;
    }
    M ans;
    for(int i=0;i<L.n;i++){//只需要以一个方阵为主
        for(int j=0;j<L.m){
            ans.mp[i][j]=L.map[i][j]+R.mp[i][j];
        }
    }
    return ans;
}
//减法
M reduce(M L,M R){
    if(L.n!=L.n||L.m!=R.m){
        return L;
    }
    M ans;
    for(int i=0;i<L.n;i++){
        for(int j=0;j<L.m;j++){
            ans.mp[i][j]=L.mp[i][j]-R.mp[i][j];
        }
    }
    return ans;
}
//乘法！！！！！！
M mult(M L,M R){
    if(L.n!=L.n||L.m!=R.m){
        return L;
    }
    M ans;
    for(int i=0;i<L.n;i++){
        for(int j=0;j<L.n;j++){
            for(int k=0;k<L.n;k++){//乘法比前面的加法还有减法多了一层循环
                ans.mp[i][j]+=L.mp[i][k]+R.mp[k][j];//最关键的一步骤
            }
        }
    }
    
}
​
int main(){
    M a,b;
    a.init(4,4);
    b.init(4,4);
    
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            scanf("%d",a.mp[i][j]);
            scanf("%d",b.mp[i][j]);
        }
    }
    M c=mult(a,b);//求两个矩阵的乘法
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            prrintf("%d",c.mp[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}
​

9、快速幂和龟速乘

(1)快速幂

假如说我们需要求的是a^b mod c怎么办喃？如果数字比较小我们可以直接就按照这个题目给的式子进行运算，但是如果b非常的话我们就需要另寻方发了。

原理：就是把b的幂次不断分解为2的幂的积。

这里需要用到位运算

 

&运算都是1，则为1，其余都是0；

 

|运算为都是0，则是0，其余都是1；

 

^运算为只要是对应位置的数字不一样，那么我们就为1，否则为0；

 

~运算为一个运算数字，可以举一个例子：假如a为10，则运算后的数字为-11；这里可能会涉及到 反码，补码，原码等，后面会出一期博客讲解。😊

 

以上三种运算都符合交换律

<<运算就是简单来说就是指翻倍，“<<”符号后面值得是要左移的位数，比如：6要左移1位，得到的数字就是12，左移2位就是24

 

 

 

">>"运算，指的就是缩小几倍，还是上图举一个栗子🌰：一个数字6，把它右移后一位就得到了3，后移两位就得到了1

 

小tips这里可以举一个位运算的例题：

在输入的5个数字中只有一个数字是落单的，请你找到他，并且把它打印出来。

思路：两个相同的数字求下来的异或是0，不相同的数字，也就是和0求异或，得到的结果是 他本身。

上代码

#include<bits/stdc++.h>
using namespace std;
int main()
{
int n1,n2,n3,n4,n5;
scanf("%d%d%d%d%d",&n1,&n2,&n3,&n4,&n5);
int ans=n1^n2;
ans=ans^n3;
ans=ans^n4;
ans=ans^n5;
printf("%d",ans);
return 0;
}

快速幂的题目栗子：

 

（1）这是我们通常的做法，这个方法好理解，但是存在着许多的缺陷（比如说可能会超出数据的范围，数据可以说是很大了）

#include<stdio.h>
int main()
{
long long a,b;
scanf("%lld%lld",&a,&b);
long long ans=1//首先把ans初始化为1
for(long long i=1;i<=b;i++){
    ans*=ans;
}
ans%=c;//得到a的b的幂次方后，我们就可以对c进行取模
return 0;
}

（2）这是我们优化后的算法，就是运用快速幂的算法

//快速幂
ll ksm(ll x, ll n, ll mod) {
    ll res = 1;
    while(n > 0) {
        if(n & 1) //等价与判断n是否为偶数，（n%2==0）
        {
             res = (res * x)% mod;
        }
        x = (x * x) % mod;
        n >>= 1;等价为 n/=2
    }
    return res;
}
​
​

（2）龟速幂

运用情景：如果我们想要计算两个很大的数（例如有longlong 范围的两个数A，B）的乘法并取模（取模的数是C）怎么办？

暂时没有懂后期更新