洛谷B2134质数的和与积

文章讲述了如何使用C++编程解决一个数学问题,即给定一个质数和S,找到两个质数之和为S时,它们的乘积的最大值。通过自定义函数判断质数并遍历计算得到答案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目描述

两个质数的和是 S,它们的积最大是多少?

输入格式

一个不大于 10000 的正整数 S,为两个质数的和。

输出格式

一个整数,为两个质数的最大乘积。数据保证有解。

思路

同样用自定义函数,从2开始,遍历到S,判断2~S间的质数与另一个质数,将最大的积存入变量,输出

代码

#include<iostream>
#include<cmath>
using namespace std;
bool an(long long num){//同样判断是否为质数
    if(num==1) return false;
    if(num==2) return true;
    for(int j=2;j<=sqrt(num);j++){
        if(num%j==0) return false;
    }
    return true;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
}
int main(){
    int a,b=0;
    cin>>a;
    for(int i=2;i<=a;i++){
    	if(an(i)&&an(a-i)&&i*(a-i)>b){//判断i和a-i是否为质数且最大
    		b=i*(a-i);//如是就存下来
		}
	}
	cout<<b<<endl;
	return 0;
}

END

卢卡斯定理(Lucas Theorem)是组合数学中用于高效计算组合数模一个质数的常用方法,尤其是在组合数的参数远大于模数的情况下。P3807题是卢卡斯定理的标准模板题之一,其核心目标是计算 $ C_{n+m}^{n} \mod p $,其中 $ n, m \leq 10^9 $,而 $ p $ 是一个质数且 $ p \leq 10^5 $。这种情况下,直接计算阶乘再取模会超出时间限制或精度限制,因此需要使用卢卡斯定理来优化计算过程。 ### 卢卡斯定理的基本思想 卢卡斯定理指出,对于非负整数 $ A, B $ 质数 $ p $,将 $ A $ $ B $ 表示为 $ p $ 进制数后,组合数模 $ p $ 的值等于各位组合数的乘模 $ p $。即: $$ C_B^A \mod p = \prod_{i=0}^{\min\{n,m\}} C_{b_i}^{a_i} \mod p $$ 其中 $ A = a_n \times p^n + a_{n-1} \times p^{n-1} + \cdots + a_0 $,$ B = b_m \times p^m + b_{m-1} \times p^{m-1} + \cdots + b_0 $。这一性质将大范围的组合数分解为多个小范围组合数的乘,便于计算[^1]。 ### 实现方法 在实现过程中,需要预先计算阶乘逆元的模值。具体来说,需要构建两个数组: - `s1[]`:存储阶乘模 $ p $ 的结果,即 $ s1[i] = i! \mod p $。 - `s2[]`:存储逆元的前缀,即 $ s2[i] = (i!)^{-1} \mod p $。 组合数 $ C_n^m \mod p $ 可以通过以下公式计算: $$ C_n^m \mod p = \frac{s1[n]}{s1[m] \cdot s1[n-m]} \mod p $$ 在模运算中,除法等价于乘以逆元。因此,可以通过预先计算阶乘逆元的数组来快速完成计算。 #### 递归实现 卢卡斯定理的递归形式为: $$ C_n^m = C_{n/p}^{m/p} \cdot C_{n \mod p}^{m \mod p} \mod p $$ 当 $ n \leq p $ 且 $ m \leq p $ 时,直接调用预处理的组合数计算函数;否则,递归地将问题分解为更小的子问题。 #### 代码实现 以下是基于上述思想的C++代码实现: ```cpp #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxn = 1e5 + 5; ll n, m, p; ll s1[maxn], s2[maxn]; // s1[]表示阶乘,s2[]表示逆元前缀 inline ll C(ll n, ll m) { return n < m ? 0 : s1[n] * s2[m] % p * s2[n - m] % p; } ll lucas(ll n, ll m) { return (n <= p && m <= p) ? C(n, m) : lucas(n % p, m % p) * lucas(n / p, m / p) % p; } inline void pre() { s1[0] = s2[0] = s2[1] = 1; // 注意s2[0]=1很重要 for (ll i = 1; i <= p; i++) s1[i] = (s1[i - 1] * i) % p; for (ll i = 2; i <= p; i++) s2[i] = (p - p / i) % p * s2[p % i] % p; for (int i = 2; i <= p; i++) s2[i] = s2[i - 1] * s2[i] % p; } int main() { int T; scanf("%d", &T); while (T--) { scanf("%lld%lld%lld", &n, &m, &p); pre(); printf("%lld\n", lucas(n + m, n)); } return 0; } ``` ### 优化注意事项 - **预处理阶乘逆元**:在每次测试用例中,都需要重新预处理阶乘逆元数组,以确保模数 $ p $ 的正确性。 - **边界条件**:当 $ n = 0 $ 或 $ m = 0 $ 时,组合数为 1,需特别处理。 - **递归终止条件**:当 $ n \leq p $ 且 $ m \leq p $ 时,可以直接调用组合数计算函数,避免不必要的递归调用。 ### 总结 卢卡斯定理通过将大范围的组合数问题分解为小范围问题,极大地提高了计算效率。结合预处理阶乘逆元数组,可以在 $ O(p) $ 的时间内完成预处理,并在 $ O(\log_p n) $ 的时间内完成每次查询。这种方法在处理组合数模质数的问题中具有广泛的应用价值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值