1.求组合数
注意根据数据范围
选择求组合数的方式
(1) 1≤n≤100000 1≤a,b≤2000
O(m2)
输出
C
a
b
m
o
d
(
1
0
9
+
7
)
C_a^b\ mod(10^9+7)
Cab mod(109+7)的值,多组输入
思路
如果硬算话,时间复杂度O(nm),105 * 2000=2 * 108会超时,不同的a,b可以构成的的对数为2000 * 2000=4 * 106,所以我们可以先求出所有 C a b C_a^b Cab的值,时间复杂度就为O(m2)
公式: C a b = C a − 1 b + C a − 1 b − 1 C_a^b=C_{a-1}^b+C_{a-1}^{b-1} Cab=Ca−1b+Ca−1b−1
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <vector>
const int maxn=2010;
const int mod=1e9+7;
using namespace std;
int c[maxn][maxn];//表示C_i^j
void init()
{
for(int i=0;i<maxn;i++)
for(int j=0;j<=i;j++)
if(j==0)
c[i][j]=1;
else
c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
}
int main()
{
int n;
cin>>n;
init();
while(n--)
{
int a,b;
cin>>a>>b;
cout<<c[a][b]<<endl;
}
return 0;
}
(2)1≤n≤100000 1≤a,b≤10^5
O(mlogk)
输出 C a b m o d ( 1 0 9 + 7 ) C_a^b\ mod(10^9+7) Cab mod(109+7)的值
我们通过求逆元的方式来做,又模数109+7是质数,所以可以用费马小定理
来做,逆元就是
a
p
−
2
a^{p-2}
ap−2。
若正整数a与素数p互质,则有 a p − 1 ≡ 1 ( m o d p ) a^{p-1}≡1(mod\ p) ap−1≡1(mod p),或写为 a p ≡ a ( m o d p ) a^p≡a(mod\ p) ap≡a(mod p)
φ ( p ) = p − 1 φ(p)=p-1 φ(p)=p−1
费马小定理求逆元
若p为素数, a p − 1 ≡ 1 ( m o d p ) a^{p-1}≡1(mod\ p) ap−1≡1(mod p) → a a p − 2 ≡ 1 ( m o d p ) aa^{p-2}≡1(mod\ p) aap−2≡1(mod p)
欧拉定理求逆元
若a,p互素, a φ ( p ) ≡ 1 ( m o d p ) a^{φ(p)}≡1(mod\ p) aφ(p)≡1(mod p) → a a φ ( p ) − 1 ≡ 1 ( m o d p ) aa^{φ(p)-1}≡1(mod\ p) aaφ(p)−1≡1(mod p)
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
int f[maxn],inv[maxn];
ll quick_pow(int a,int k,int p)
{
ll ans=1%p;
while(k)//即使指数有10^9,进行运算的次数也不过30次左右
{
if(k&1)
ans=1ll*ans*a%p;
a=1ll*a*a%p;
k>>=1;
}
return ans;
}
int main()
{
f[0]=inv[0]=1;
for(int i=1;i<maxn;i++)//预处理求出所有的阶乘和逆元
{
f[i]=(ll)f[i-1]*i%mod;
inv[i]=(ll)inv[i-1]*quick_pow(i,mod-2,mod)%mod;
}
int n;
cin>>n;
while(n--)
{
int a,b;
cin>>a>>b;
int ans=(ll)f[a]*inv[b]%mod*inv[a-b]%mod;//要及时取模,三个10^9相乘会溢出long long
cout<<ans<<endl;
}
return 0;
}
( k ! ) − 1 ≡ ( k ! ) p − 2 ≡ ( ( k − 1 ) ! ) − 1 × k − 1 ≡ ( ( k − 1 ) ! ) − 1 × k p − 2 ( m o d p ) (k!)^{-1} \equiv (k!)^{p-2} \equiv ((k-1)!)^{-1} \times k^{-1} \equiv ((k-1)!)^{-1} \times k^{p-2} (mod \ p) (k!)−1≡(k!)p−2≡((k−1)!)−1×k−1≡((k−1)!)−1×kp−2(mod p)
(3)1≤n≤20 1≤a,b≤10^18 1≤p≤10^5
O
(
l
o
g
p
m
∗
p
l
o
g
p
)
O(log_pm*plogp)
O(logpm∗plogp) ~ p logm logp*n ~ 105 * 64 * 20 * 20(组) ~ 4 * 107 (64可以不要是因为p取极值时,
l
o
g
p
m
log_pm
logpm会很小)
输出 C a b m o d p C_a^b\ mod\ p Cab mod p 的值,其中p为质数
Lucas定理
C a b ≡ C a m o d p b m o d p C a / p b / p ( m o d p ) C_a^b\equiv C_{a\ mod\ p}^{b\ mod\ p}C_{a/p}^{b/p}\ (mod\ p) Cab≡Ca mod pb mod pCa/pb/p (mod p)
证明:
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
int quick_pow(int a,int k,int p)
{
int ans=1%p;
while(k)//即使指数有10^9,进行运算的次数也不过30次左右
{
if(k&1)
ans=(ll)ans*a%p;
a=(ll)a*a%p;
k>>=1;
}
return ans;
}
int C(int a,int b,int p)
{
if(b>a)
return 0;
int ans=1;
for(int i=1,j=a;i<=b;i++,j--)
{
ans=(ll)ans*j%p;//a*...*(a-b+1)
ans=(ll)ans*quick_pow(i,p-2,p)%p;//b!
}
return ans;
}
int lucas(ll a,ll b,int p)
{
if(a<p&&b<p)
return C(a,b,p);
return (ll)C(a%p,b%p,p)*lucas(a/p,b/p,p)%p;
}
int main()
{
int n;
cin>>n;
while(n--)
{
ll a,b;
int p;
cin>>a>>b>>p;
cout<<lucas(a,b,p)<<endl;
}
return 0;
}
上述代码为在线处理(边输入便处理求值),离线处理(提前都算好存储下来)时间复杂度上可能还会更好一些
(4)1≤a,b≤5000 不取模
输出
C
a
b
C_a^b
Cab 的值,不取模结果可能很大,需要使用高精度计算
如果直接大数运算,实现一个大数乘和大数除,但是直接这样按公式做乘除,效率会比较低
我们可以把
C
a
b
C_a^b
Cab进行质因数分解,然后只需要做大数乘即可。如果对分子分母每一个数做质因数分解,时间复杂度为n√n
,效率不是很高。
思路
C a b = a ! b ! ( a − b ) ! C_a^b=\frac{a!}{b!(a-b)!} Cab=b!(a−b)!a!,对于一个质因子p,分母中p的个数-分子中p的个数即是p在 C a b C_a^b Cab中出现的次数
1.筛出1 ~ n中的素数(由素数分布知,素数个数很少,即使1~1e6中也只有5e4个左右)
2.计算每个素数的次数
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
int primes[maxn],cnt;
bool st[maxn];
int pnums[maxn];
void get_primes(int n)
{
for(int i=2;i<=n;i++)
{
if(!st[i])
primes[cnt++]=i;
for(int j=0;primes[j]<=n/i;j++)
{
st[primes[j]*i]=true;
if(i%primes[j]==0)
break;
}
}
}
int get_pow(int n,int p)//求n!里有多少个p
{
int ans=0;
while(n)
{
ans+=n/p;
n/=p;
}
return ans;
}
vector<int> mul(vector<int> a,int b)
{
vector<int> ans;
int t=0;
for(int i=0;i<a.size();i++)
{
t+=a[i]*b;
ans.push_back(t%10);
t/=10;
}
while(t)
{
ans.push_back(t%10);
t/=10;
}
return ans;
}
int main()
{
int a,b;
cin>>a>>b;
get_primes(a);
for(int i=0;i<cnt;i++)
{
int p=primes[i];
pnums[i]=get_pow(a,p)-get_pow(b,p)-get_pow(a-b,p);
}
vector<int> ans;
ans.push_back(1);
for(int i=0;i<cnt;i++)
for(int j=0;j<pnums[i];j++)//注意这里不用快速幂,直接大数*小数
ans=mul(ans,primes[i]);
for(int i=ans.size()-1;i>=0;i--)
cout<<ans[i];
cout<<endl;
return 0;
}
这里不使用快速幂,因为使用之后会变成两个高精度整数的乘法。如果高精度的数的长度是
L
L
L,幂的次数是
N
N
N,那么用快速幂(朴素的两个高精度相乘)的时间复杂度是
O
(
L
2
l
o
g
N
)
O(L^2logN)
O(L2logN),如果用FFT可以优化到
O
(
L
l
o
g
L
l
o
g
N
)
O(LlogLlogN)
O(LlogLlogN);如果不用快速幂(不用快速幂虽然乘的次数会变多,但乘法本身是高精度乘以低精度),那么时间复杂度是
O
(
L
N
)
O(LN)
O(LN)。
for(int i=0;i<cnt;i++)
res=mul(res,quick_pow(primes[i],pnums[i]));
比较神奇的技巧:手动开O2优化
#pragma GCC optimize(2)
2.卡特兰数
例题
输入
3
输出
5
代码
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
//可以用快速幂来求逆元是因为mod是个质数,如果不是质数,只能用扩展欧几里得来算了
int quick_pow(int a,int k,int p)
{
int ans=1%p;
while(k)
{
if(k&1)
ans=1ll*ans*a%p;
a=1ll*a*a%p;
k>>=1;
}
return ans;
}
int Catalan(int n)
{
int a=2*n,b=n;
int ans=1;
for(int i=a;i>a-b;i--)
ans=1ll*ans*i%mod;
for(int i=1;i<=b;i++)
ans=1ll*ans*quick_pow(i,mod-2,mod)%mod;
ans=1ll*ans*quick_pow(n+1,mod-2,mod)%mod;
return ans;
}
int main()
{
int n;
cin>>n;
cout<<Catalan(n)<<endl;
return 0;
}
用exgcd求逆元:ax≡c(mod b)<=>
ax+by=c (用exgcd求解)
相当于ax+by=c(gcd(a,b)|c)
的c=1
,a,b要互质咯,求出x即可。
3.容斥原理
O(2m)
例题 能被整除的数
输入
10 2
2 3
输出
7
思路
如果暴力去做,枚举n个数以及枚举m个质数,时间复杂度为O(nm)的,n就已经109了,所以不行,一定要用容斥原理
做。对于每个质数
,建立一个1~n
内的倍数集合,然后用容斥原理去算,时间复杂度为O(2m),216=65536,1s能算107~108,所以是ok的。
∣ s p ∣ |s_p| ∣sp∣:1~n中p的倍数的个数 ⌊ n p ⌋ ⌊\frac{n}{p}⌋ ⌊pn⌋ 1p,2p,…,kp
∣ s 2 ∩ s 3 ∣ |s_2∩s_3| ∣s2∩s3∣:6的倍数 ⌊ n 2 ∗ 3 ⌋ ⌊\frac{n}{2*3}⌋ ⌊2∗3n⌋
∣ s i ∩ s j ∩ . . . ∩ s k ∣ |s_i∩s_j∩...∩s_k| ∣si∩sj∩...∩sk∣: ⌊ n i ∗ j . . . ∗ k ⌋ ⌊\frac{n}{i*j...*k}⌋ ⌊i∗j...∗kn⌋
注意到这里给出的都是质数 p i p_i pi,所以他们都是互质的,直接相乘就可以。如果不互质,那就求他们的最小公倍数。然后个数是 n l c m ( i , j , k ) \frac{n}{lcm(i,j,k)} lcm(i,j,k)n
时间复杂度分析:
求集合的时间复杂度为O(k),因为要进行k次乘法运算,进行容斥原理计算时间复杂度为O(2m),总的时间复杂度为 O ( 2 m ∗ m ) O(2^m*m) O(2m∗m) -> 216*24=220=106
容斥那个式子怎么来实现呢,可以用爆搜去枚举每一个组合,但是这里推荐用位运算来做,每一个二进制序列对应一种集合的组合。
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=20;
const int mod=1e9+7;
int p[maxn];
int main()
{
int n,m;
cin>>n>>m;
for(int i=0;i<m;i++)
cin>>p[i];
int ans=0;
for(int i=1;i<1<<m;i++)//2^m用1左移m位来表示
{
int t=1;//表示当前所有质数的乘积
int cnt=0;//当前i里包含几个1,即当前|..∩..|里有几个集合
for(int j=0;j<m;j++)//枚举m位
{
if(i>>j&1)//如果当前这位是1,即这个|..∩..|有这个p
{
if(1ll*t*p[j]>n)//给出的p范围很大,可能会比n大,这个组合就肯定不存在
{
t=-1;
break;
}
cnt++;
t*=p[j];//i*j*k...
}
}
if(t!=-1)
{
if(cnt%2)//奇数
ans+=n/t;//系数是(-1)^(k-1)
else//偶数
ans-=n/t;
}
}
cout<<ans<<endl;
return 0;
}
深搜版
单纯改成dfs (上述二进制的代码会更精简)
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=20;
const int mod=1e9+7;
int p[maxn],s[maxn];
ll ans;
int n,m;
void dfs(int k)
{
if(k==m)
{
int t=1,cnt=0;
for(int i=0;i<m;i++)
{
if(s[i])//这一位是1
{
cnt++;
if(1ll*t*p[i]>n)
return ;
t*=p[i];
}
}
if(cnt%2)
ans+=n/t;
else
ans-=n/t;
}else
{
s[k]=0;
dfs(k+1);
s[k]=1;
dfs(k+1);
}
}
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
cin>>p[i];
dfs(0);
cout<<ans+n<<endl;//可以出现00..0的情况,t=1,就会多减n
return 0;
}
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=20;
const int mod=1e9+7;
int p[maxn],s[maxn];
ll ans;
int n,m;
void dfs(ll mul,ll k,ll cnt)
{
if(k==m)
{
if(cnt)//排除00..0的情况
{
if(cnt%2)
ans+=n/mul;
else
ans-=n/mul;
}
}else
{
dfs(mul,k+1,cnt);
dfs(mul*p[k],k+1,cnt+1);
}
}
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
cin>>p[i];
dfs(1,0,0);
cout<<ans<<endl;
return 0;
}