《算法笔记》编程笔记——第五章：简单数学题

梦想总比行动多

已于 2022-03-24 15:02:33 修改

阅读量130

点赞数

分类专栏： PAT 文章标签：算法

于 2021-03-03 21:56:07 首次发布

本文链接：https://blog.csdn.net/qq_43505469/article/details/114337645

版权

PAT 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

《算法笔记》编程笔记——第五章：简单数学题

一、最大公约数与最小公倍数

//最大公约数的递归计算公式
int gcd(int a, int b){
    if(b == 0)return a; //0和任意一个整数a的最大公约数都是a，注意不是0
    else return gcd(b, a % b);
}

二、分数的计算

分数的化简：①结果为负，分子分母变为相反数（最简需要分母为正）；②结果为0，使分子为0，分母为1；③其他情况下，计算出分子分母最大公约数，分别除以最大公约数，表示约分。
分数的加减乘除，按数学公式书写代码即可；注意数据类型最好使用long long 类型。

代码模板如下：

//首先用结构体来存放分数
struct Fraction{
    long long  up, down;
};
//分数化简
Fraction reduction(Fraction result){
    if(result.down < 0){
        result.up = -result.up;
        result.down = -result.down;
    }
    if(result.up == 0)result.down = 1;
    else{
        int d = gcd(abs(result.up), abs(result.down));
        result.up /= d;
        result.down /= d;
    }
    return result;
}

//分数运算(加减乘除的式子)

//分数输出
void showResult(Fraction r){
    r  = reduction(r);//先进行分数化简
    if(r.down == 1)printf("%lld", r.up);
    else{
        printf("%d/%d", r.up, r.down);
    }
}

三、素数

素数判断常用代码块：

//通常求素数直接用平方法进行判断即可。
bool isPrime(int n){
    if(n == 1)return false;
    int sqr = (int)sqrt(1.0 * n);//sqrt头文件为math.h,同时，sqrt只能开浮点类型，所以需要 * 1.0
    for(int i = 2; i <= sqr; i++){
        if(n % i == 0)return false;
    }
    return true;
}
//如果n没哟接近int变量的范围上界，还有更加简便的方法
bool isPrime(int n){
    if(n <= 1)return false;
    for(int i = 2; i * i <= n; i++){
        if(n % i == 0)return false;
    }
    return true;
}

//求素数表
int prime[maxn], pNum = 0;
void find_prime(){
    for(int i = 1; i < maxn; i++){
        if(is_prime(i) == true){
            prime[pNum++] = 1;
        }
    }
}

传统求素数法，只适用于n小于10^5，如果n大于这个值时，适合用“埃氏筛法”求素数。但是“埃氏筛法”当数字太大时，p数组无法开那么大，这也是个缺陷。

//寻找[1-100]之间的素数。maxn设置为101，而不是100
const int maxn = 101;//找的数的上界，注意要比n大1
int prime[maxn], pNum = 0;
unordered_map<int, int> p//标记数是否为素数,为0表示是素数，为1表示不是素数
void find_prime(){
    for(int i = 2; i < maxn; i++){ //注意循环从2开始，因为1既不是素数也不是偶数
        if(p[i] == 0){
            prime[pNum++] = i;
            //将素数的倍数的数全部标记为合数。
            for(int j = i + i; j < maxn; j += i){
                p[j] = 1;
            }
        }
    }
}

四、质因子分解

分解思路：

struct factor{
    int x, cnt;
}fac[10];//在int范围内，fac数组只要开10就足够用
//思路是，质因子的个数如果大于2，也就是不是1和这个数本身，那么必定存在质因子小于等于sqrt(n)；反之，就是1和其本身
//找出所有的质因数（素数），然后再判断是否为此数的质因数。
if(n % prime[i] == 0){//是质因数
    fac[num].x = prime[i];
    fac[num].cnt = 0;
    while(n % prime[i] == 0){
        fac[num].cnt++;//计算此质因数的个数
        n /= prime[i];
    }
    num++;//个数计算结束，num增加
}
//当上面的计算结果显示n仍大于1的时候，说明该数是一个质数。
if(n != 1){
    fac[num].x = n;
    fac[num].cnt = 1;
}

五、大整数计算

//大整数的存储
struct bign{
    int d[1000];
    int len;
    //构造函数对结构体进行初始化,函数名与结构体名一致
    bign(){
        memset(d, 0, sizeof(d));
        len = 0;
    }
}
//然后将大整数按字符串的方式读入到字符数组中，再将字符数组转为到结构体中的整数数组中（是字符数组最后一位到整数数组第一位）。
bign change(char str[]){
    bign a;
    a.len = strlen(str);
    for(int i = 0; i < a.len; i++){
        a.d[i] = str[a.len - i - 1] - '0';//逆序转换为数字存储
    }
    return a;
}
//比较两个bign变量的大小
int compare(bign a, bign b){
    if(a.len > b.len)return 1;//如果a的长度大，那就说明a数大，返回-1
    else if(a.len < b.len)return -1;//b大
    else{
        for(int i = a.len - 1;i >= 0; i--){//表示从高位往低位进行比较
            if(a.d[i] > b.d[i]) return 1;
            else if(a.d[i] < b.d[i]) return -1;
        }
        return 0;//两数相等
    }
}

高精度与高精度加法

bign add(bign a, bign b){//传入结构体 
	bign c;
	int carry = 0;//进位初始化
	for(int i = 0; i < a.len || i < b.len; i++){
		int temp = a.d[i] + b.d[i] + carry;
		c.d[i] = temp % 10;
		c.len++;
		carry = temp / 10;
	} 
	if(carry != 0){//最高位有进位的时候
		c.d[len++] = carry;
	}
	return c;
}

高精度与低精度乘法

bign multi(bign a, int b){
    bign c;
	int carry = 0;
	for(int i = 0; i < a.len; i++){
		int temp = a.d[i] * b + carry;
		//下面的部分与加法类似 
		c.d[c.len++] = temp % 10;//个位作为该位结果
		carry = temp / 10; //高位部分作为新的进位
	}
	while(carry != 0){//和加法不一致之处在于乘法的进位可能不只一位 
		c.d[c.len++] = carry % 10;
		carry /= 10;
	}
	return c;
}

高精度数减法

注意点：事先比较两数的大小，保证减数大；如果原先结果为负，只要添负号即可。

bign sub(bign a, bign b){
	bign c;
	for(int i = 0; i < a.len || i < b.len; i++){
		if(a.d[i] < b.d[i]){//这位上的数字不够减 
			a.d[i+1]--;
			a.d[i] += 10;
		}
		c.d[c.len++] = a.d[i] - b.d[i];
	}
	//去除减数最高位为0的，同时保证至少保留一位数字 
	if(c.len - 1 >= 1 && c.d[c.len - 1] == 0){
		c.len--;
	}
	return c;
}

高精度与低精度除法

bign divide(bign a, int b, int &r){//考虑到很多时候余数要返回，所以引用使用 
	r = 0;
	bign c;
	c.len = a.len;
	for(int i = a.len - 1; i >= 0; i--){//从高位开始计算 
		r = r * 10 + a.d[i];//将上次遗留的余数加上
		if(r < b){
			c.d[i] = 0;//数组下标直接就是i，因为在前面已经让c的len等于a的len 
		} 
		else{
			c.d[i] = r / b;//商 
			r = r % b;//新的余数 
		}
	}
    //乘除法的进位与借位都用while循环来判断
	while(c.len - 1 >= 1 && c.d[c.len - 1] == 0){
		c.len--; //去除高位的0，同时至少保留一位最低位
	}
	return c;
}

六、组合数(需要更加熟悉)

（n！）的质因子p个数：算法复杂度为O(logn)

//n!(个数) = (n/p + n/(p^2) + n/(p^3)+……)
//代码如下：
int cal(int n, int p){
    int ans = 0;
    while(n){
        ans += n / p;
        n /= p;
    }
    return ans;
}
//也有式子：n!(个数) = n / p + (n / p)!(个数)故有以下递归算法
int cal(int n, int p){
    if(n < p)return 0;
    return n / p + cal(n / p, p);
}

组合数的计算：C（m, n) % p. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ykbqIkZ-1614779751836)(C:\Users\dd\AppData\Roaming\Typora\typora-user-images\image-20201002104101021.png)]

//一、递推法，适用于m<=n<=1000, p <= 10^9（素性没有限制）
void calC(){
    for(int i = 0; i <= n; i++){//边界标记
        res[i][0] = res[i][i] = 1;
    }
    //注意i和j开始的值
    for(int i = 2; i <= n; i++){
        for(int j = 1; j <= i / 2; j++){
            res[i][j] = (res[i-1][j] + res[i-1][j-1]) % p;//公式
            res[i][i-j] = res[i][j]; //组合数对称相等的关系
        }
    }
}
//递归式, C(n, m) = C(n-1, m) + C(n-1, m-1);边界C(n, 0) = C(n, n) = 1;
int c(int n, int m, int p){
    if(m==0 || m == n)return 1;//组合数全选和全部选的种数
    if(res[n][m] != 0)return res[n][m];//表示已经有值计算出来，直接调用就可以
    return res[n][m] = (c(n-1, m) + c(n-1, m-1))%p;//赋值并返回
}


//二、定义式计算，适用于m<=n<=10^6, p <= 10^9(p的素性没有限制)
//思路：将组合数进行质因子分解，假设分解结果为C = p1^c1 * p2^cc2 * p3^c3……%p;
//需要先将<=n的素数全部找出
int prime[maxn];
//cal()函数,计算质因数p的个数
int cal(int n, int p){
    int ans = 0;
    while(n){
        ans += n / p;
        n /= p;
    }
    return ans;
}
//快速幂函数
typedef long long LL;
LL binaryPow(LL a, LL b, LL m){
    if(b == 0)return 1;//一个数的0次方为1
    if(b % 2 == 0)return a * binaryPow(a, b - 1, m) % m;//此处b % 2 == 0 可以用 if(b & 1)代替，判断b的末尾是否为1，进行了位与操作。可以加快执行速度
    else{//b为偶数
        LL mul = binaryPow(a, b / 2, m);//此处先算出单个，最后再相乘，降低时间复杂度
        return mul * mul % m;//得到结果
    }
}
//计算C(n, m) % p;
int calC(int n, int m, int p){
    int ans = 1;
    for(int i = 0; prime[i] <= n; i++){
        //cal（）函数为计算阶乘质因子的个数
        //下面的公式就是计算每个阶乘关于p的质因子的个数。
      int c = cal(n, prime[i]) - cal(m, prime[i]) - cal(n - m, prime[i]);
        //快速幂计算公式，计算prime[i]^c % p
        ans = ans * binaryPow(prime[i], c, p);
    }
    return ans;
}

//卢卡斯定理计算，适用于n.m<= 10^18，p <= 10^且p是素数
int Lucas(int n, int m){
    if(m == 0)return 1;
    return CalC(n%p, m%p) * Lucas(n / p, m / p) % p;//此处将p作为全局变量，所以没有在函数内进行传值。
}

扩展欧几里得算法

梦想总比行动多

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
《算法笔记》编程笔记——第五章：简单数学题

《算法笔记》编程笔记——第五章：简单数学题一、最大公约数与最小公倍数//最大公约数的递归计算公式int gcd(int a, int b){ if(b == 0)return a; //0和任意一个整数a的最大公约数都是a，注意不是0 else return gcd(b, a % b);}二、分数的计算分数的化简：①结果为负，分子分母变为相反数（最简需要分母为正）；②结果为0，使分子为0，分母为1；③其他情况下，计算出分子分母最大公约数，分别除以最大公约数，表示约分。
复制链接

扫一扫