组合数相关问题

最新推荐文章于 2021-08-09 22:14:25 发布

Nismilesucc

最新推荐文章于 2021-08-09 22:14:25 发布

阅读量450

点赞数

分类专栏：算法竞赛知识点整理

HUIKI

本文链接：https://blog.csdn.net/Nismilesucc/article/details/107900443

版权

算法竞赛知识点整理专栏收录该内容

40 篇文章 5 订阅

订阅专栏

`1.求组合数`

注意根据数据范围选择求组合数的方式

`(1) 1≤n≤100000 1≤a,b≤2000` O(m²)

输出 $C_a^b\ mod(10^9+7)$ 的值，多组输入
在这里插入图片描述

思路

如果硬算话，时间复杂度O(nm)，10⁵ * 2000=2 * 10⁸会超时，不同的a,b可以构成的的对数为2000 * 2000=4 * 10⁶，所以我们可以先求出所有 $C_a^b$ 的值，时间复杂度就为O(m²)

公式： $C_a^b=C_{a-1}^b+C_{a-1}^{b-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\ mod(10^9+7)$ 的值

我们通过求逆元的方式来做，又模数10⁹+7是质数，所以可以用费马小定理来做，逆元就是 $a^{p-2}$ 。

若正整数a与素数p互质，则有 $a^{p-1}≡1(mod\ p)$ ,或写为 $a^p≡a(mod\ p)$

$φ (p) = p - 1$

费马小定理求逆元

若p为素数， $a^{p-1}≡1(mod\ p)$ → $aa^{p-2}≡1(mod\ p)$

欧拉定理求逆元

若a,p互素， $a^{φ(p)}≡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} \equiv (k!)^{p-2} \equiv ((k-1)!)^{-1} \times k^{-1} \equiv ((k-1)!)^{-1} \times k^{p-2} (mod \ p)$

`(3)1≤n≤20 1≤a,b≤10^18 1≤p≤10^5` $O(log_pmplogp)$ ~ p logm logpn ~ 10⁵ * 64 * 20 * 20(组) ~ 4 * 10⁷ (64可以不要是因为p取极值时， $log_pm$ 会很小)

输出 $C_a^b\ mod\ p$ 的值,其中p为质数

`Lucas定理`

$C_a^b\equiv C_{a\ mod\ p}^{b\ mod\ p}C_{a/p}^{b/p}\ (mod\ p)$

证明：
在这里插入图片描述

Lucas定理推导过程+模板

#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$ 进行质因数分解，然后只需要做大数乘即可。如果对分子分母每一个数做质因数分解，时间复杂度为n√n，效率不是很高。

思路

$C_a^b=\frac{a!}{b!(a-b)!}$ ，对于一个质因子p，分母中p的个数-分子中p的个数即是p在 $C_a^b$ 中出现的次数

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$ ，幂的次数是 $N$ ，那么用快速幂（朴素的两个高精度相乘）的时间复杂度是 $O(L^2logN)$ ，如果用FFT可以优化到 $O (L l o g L l o g N)$ ；如果不用快速幂（不用快速幂虽然乘的次数会变多，但乘法本身是高精度乘以低精度），那么时间复杂度是 $O (L N)$ 。

 for(int i=0;i<cnt;i++) 
        res=mul(res,quick_pow(primes[i],pnums[i]));

比较神奇的技巧：手动开O2优化

#pragma GCC optimize(2)

在这里插入图片描述

`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;
//可以用快速幂来求逆元是因为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(2^m)

在这里插入图片描述

例题能被整除的数

在这里插入图片描述

输入

10 2
2 3

输出

思路

如果暴力去做，枚举n个数以及枚举m个质数，时间复杂度为O(nm)的，n就已经10⁹了，所以不行，一定要用容斥原理做。对于每个质数，建立一个1~n内的倍数集合，然后用容斥原理去算，时间复杂度为O(2^m)，2¹⁶=65536，1s能算10⁷~10⁸，所以是ok的。

$s_p|$ ：1~n中p的倍数的个数 $⌊\frac{n}{p}⌋$ 1p,2p,…,kp

$s_2∩s_3|$ ：6的倍数 $⌊\frac{n}{2*3}⌋$

$s_i∩s_j∩...∩s_k|$ ： $⌊\frac{n}{i*j...*k}⌋$

注意到这里给出的都是质数 $p_i$ ，所以他们都是互质的，直接相乘就可以。如果不互质，那就求他们的最小公倍数。然后个数是 $\frac{n}{lcm(i,j,k)}$

`时间复杂度分析：`

求集合的时间复杂度为O(k)，因为要进行k次乘法运算，进行容斥原理计算时间复杂度为O(2^m)，总的时间复杂度为 $O(2^m*m)$ -> 2¹⁶*2⁴=2²⁰=10⁶

`容斥那个式子怎么来实现呢，可以用爆搜去枚举每一个组合，但是这里推荐用位运算来做，每一个二进制序列对应一种集合的组合。`

#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;
}

Nismilesucc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
组合数相关问题

1.容斥原理注意根据数据范围选择求组合数的方式(1) <2000如果硬算话，时间复杂度O(nm)，105 * 2000=2 * 108会超时，不同的a,b可以构成的的对数为2000 * 2000=4 * 106，所以我们可以先求出所有CabC_a^bCab的值2.容斥原理例题能被整除的数输入10 22 3输出7代码如果暴力去做，枚举n个数以及枚举m个质数，时间复杂度为O(nm)的，n就已经109了，所以不行，一定要用容斥原理做。对于每个质数，建立一个1~n内的倍
复制链接

扫一扫