0x36 组合计数

组合计算的性质：

C(n,m)= m! / (n!(m-n)!)

C(n,m)=C(m-n,m); C(n,m)=C(n,m-1)+C(n-1,m-1);

二项式定理：(a+b)^n=sigema(k=0~n) C(k,n)*a^k*b^(n-k)

lucas定理：C(n,m)≡C(n%p,m%p)*C(n/p,m/p)  (mod p)

catalan数: Cat(n)=C(n,2n)/n+1  Cat(n)=Cat(n-1)*(4n-2)/(n+1)

计算系数 通过二项式定理变形其实就是求C(n,k)*a^n*b^m，用下逆元

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const LL mod=;
 
LL quick_pow(LL A,LL p)
{
    int ret=;
    while(p!=)
    {
        if(p%==)ret=(ret*A)%mod;
        A=(A*A)%mod;p/=;
    }
    return ret;
}
LL jiecheng(LL k)
{
    LL ret=;
    for(int i=;i<=k;i++)ret=(ret*i)%mod;
    return ret;
}
LL getniyuan(LL k)
{
    return quick_pow(k,mod-);
}
 
int main()
{
    LL a,b,k,n,m;
    scanf("%lld%lld%lld%lld%lld",&a,&b,&k,&n,&m);
    LL ans=( (jiecheng(k)*getniyuan( jiecheng(n)*jiecheng(k-n)%mod )%mod) *
              (quick_pow(a,n)*quick_pow(b,m)%mod) )%mod;
    printf("%lld\n",ans);
    return ;
}

计算系数

Counting Swaps 神仙题，%lyd吧。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const LL mod=1e9+;
 
LL quick_pow(LL A,LL p)
{
    int ret=;
    while(p!=)
    {
        if(p%==)ret=(ret*A)%mod;
        A=(A*A)%mod;p/=;
    }
    return ret;
}
LL jiecheng(LL k)
{
    LL ret=;
    for(int i=;i<=k;i++)ret=(ret*i)%mod;
    return ret;
}
LL getniyuan(LL k)
{
    return quick_pow(k,mod-);
}
 
int nxt[];
bool v[];
LL dfs(int x,int d)
{
    if(v[x]==true)return d;
    v[x]=true;
    dfs(nxt[x],d+);
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=;i<=n;i++)scanf("%d",&nxt[i]);
 
        LL tot=,ans=,cnt;cnt=n;
        memset(v,false,sizeof(v));
        for(int i=;i<=n;i++)
        {
            if(v[i]==false)
            {
                int L=dfs(i,);
                if(L>)
                {
                    tot++;
                    ans=(ans*quick_pow(L,L-)%mod)*getniyuan(jiecheng(L-))%mod;
                }
                else cnt--;
            }
        }
        if(tot==)printf("1\n");
        else
        {
            ans=ans*jiecheng(cnt-tot)%mod;
            printf("%lld\n",ans);
        }
    }
    return ;
}

Count Swaps

bzoj1951 由欧拉定理的推论，变成计算sigema(d|n)C(d,n)%(mod-1)，这个用卢卡斯定理搞，但是mod不是质数，那么分解分别搞，然后得到4个同余方程，解出就是指数了，最后快速幂即可。

upd:感觉之前的阶乘模数有点假。。但是应该是对的

快速幂+crt并没有exgcd优秀的说。。。卡了一波常数才过的。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const LL mod=;
const LL md[]={,,,};
 
int quick_pow(int A,int p,int mod)
{
    int ret=;
    while(p!=)
    {
        if(p%==)ret=(LL)ret*A%mod;
        A=(LL)A*A%mod;p/=;
    }
    return ret;
}
LL fac[][],fac_inv[][];
void initC()
{
    for(int j=;j<=;j++)fac[j][]=,fac_inv[j][]=;
    for(int i=;i<=md[];i++)
        for(int j=;j<=;j++)
            fac[j][i]=fac[j][i-]*i%md[j],fac_inv[j][i]=quick_pow(fac[j][i],md[j]-,md[j]);
}
LL getC(LL n,LL m,LL p){return fac[p][n]*fac_inv[p][m]%md[p]*fac_inv[p][n-m]%md[p];}
LL lucas(LL n,LL m,LL p)
{
    LL ans=;
    while(m>)
    {
        LL a=n%md[p],b=m%md[p];
        if(a<b)return ;
        ans=ans*getC(a,b,p)%md[p];
        n/=md[p],m/=md[p];
    }
    return ans;
}
 
LL a[];
LL solve(LL n,LL k)
{
    for(int i=;i<=;i++)a[i]=lucas(n,k,i);
    LL M=mod-,x=;
    for(int i=;i<=;i++)//crt
        x=(x+a[i]*(M/md[i])*quick_pow(M/md[i],md[i]-,md[i]))%(mod-);
    return x;
}
 
int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    initC();
    int n,G,p=;
    scanf("%d%d",&n,&G);
    if(G==mod){printf("0\n");return ;}
    for(int i=;i*i<=n;i++)
        if(n%i==)
        {
            p=(p+solve(n,i))%(mod-);
            if(i*i!=n)p=(p+solve(n,n/i))%(mod-);
        }
    printf("%d\n",quick_pow(G,p,mod));
    return ;
}

bzoj1951(upd)

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const LL mod=;
const LL md[]={,,,};
 
LL exgcd(LL a,LL b,LL &x,LL &y)
{
    if(a==)
    {
        x=;y=;
        return b;
    }
    else
    {
        LL tx,ty;
        LL d=exgcd(b%a,a,tx,ty);
        x=ty-b/a*tx;
        y=tx;
        return d;
    }
}
LL quick_pow(LL A,LL p)
{
    LL ret=;
    while(p!=)
    {
        if(p%==)ret=(ret*A)%mod;
        A=(A*A)%mod;p/=;
    }
    return ret;
}
LL inv(LL a,LL p)
{
    LL x,y;
    LL d=exgcd(a,p,x,y);
    return (x%p+p)%p;
}
 
//---------------------------------------------------
 
LL jc[];
LL lucas(LL N,LL M,LL p)
{
    LL ans=;
    while(M>)
    {
        LL a=N%p,b=M%p;
        if(a>b)return ;
 
        ans=ans*jc[b]%p;
        ans=ans*inv(jc[a],p)%p;
        ans=ans*inv(jc[b-a],p)%p;
 
        N/=p;M/=p;
    }
    return ans;
}//lucas
LL g[];
void getzs(LL n)
{
    jc[]=;
    for(int i=;i<=md[];i++)jc[i]=(jc[i-]*i)%(mod-);
 
    for(int i=;i*i<=n;i++)
    {
        if(n%i==)
        {
            for(int j=;j<=;j++)
                g[j]=(g[j]+lucas(i,n,md[j]))%md[j];
            if(i!=n/i)
            {
                for(int j=;j<=;j++)
                    g[j]=(g[j]+lucas(n/i,n,md[j]))%md[j];
            }
        }
    }
}
 
//---------------------------------------------------
 
LL u1,v1,u2,v2;
void merge()
{
    LL A=u1,B=u2,K=v2-v1,x,y;
    LL d=exgcd(A,B,x,y);
 
    x=(x*(K/d)%(B/d)+(B/d))%(B/d);
    v1=u1*x+v1;
    u1=u1/d*u2;
}
LL solve()
{
    u1=md[],v1=g[];
    for(int i=;i<=;i++)
        u2=md[i], v2=g[i], merge();
    return v1;
}
 
int main()
{
    LL n,g;
    scanf("%lld%lld",&n,&g);g%=mod;
    if(g==){printf("0\n");return ;}
 
    getzs(n);
    LL p=solve();
    printf("%lld\n",quick_pow(g,p));
    return ;
}

bzoj1951