一些数论的板子

1.线性筛逆元

for(ll i=2;i<=n;i++)
        inv[i]=(mod-mod/i)*inv[mod%i]%mod;

 2.快速乘

return ((a*b-(ll)(long double)a/p*b+1e-8)*p+p)%p;

 3.excrt

namespace excrt{
ll ans=0,M=1;
int insert(ll A,ll B)
{
    ll a=A,b=B,c=(a-ans%b+b)%b,x,y;
    ll g=exgcd(M,b,x,y);
    ll bg=b/g;
    //if(c%g!=0) return -1;
    x=qadd(x,c/g,bg);
    ans+=x*M,M*=bg,ans=(ans%M+M)%M;
    return 1;
}
};

4.exlucas

namespace exlucas{
ll ans=0,M=1;
ll son[10],pw[10];
int num;
int excrt_ins(ll A,ll B)
{
    ll a=A,b=B,c=(a-ans%b+b)%b,x,y;
    ll g=exgcd(M,b,x,y);ll bg=b/g;
    if(c%g!=0) return -1;
    x=qmul(x,c/g,bg);
    ans+=x*M,M*=bg,ans=(ans%M+M)%M;
    return 1;
}
ll get_mul(ll n,ll p,ll &sum,const ll &mo,int type)
{
    if(n==0) return 1;
    ll ans=1;
    for(int i=2;i<=min(n,mo);i++)
        if(i%p) ans=ans*i%mo;
    ans=qpow(ans,n/mo,mo);
    for(int i=2;i<=n%mo;i++)
        if(i%p) ans=ans*i%mo;
    sum+=1ll*(n/p)*type;
    return ans*get_mul(n/p,p,sum,mo,type)%mo;
}
ll get_C(ll n,ll m,ll p,const ll &mo)
{
    if(m>n) return 0;
    ll sum=0;ll y;
    ll nn=get_mul(n,p,sum,mo,1);
    ll mm=get_mul(m,p,sum,mo,-1);
    ll nm=get_mul(n-m,p,sum,mo,-1);
    exgcd(mm,mo,mm,y);
    mm=(mm%mo+mo)%mo;
    exgcd(nm,mo,nm,y);
    nm=(nm%mo+mo)%mo;
    return nn*mm%mo*nm%mo*qpow(p,sum,mo)%mo;
}
ll C(ll n,ll m,const ll &mo)
{
    if(m>n) return 0;
    ll ret=0;
    for(int i=0;i<num;i++){
        ll val=get_C(n,m,son[i],pw[i]);
        excrt_ins(val,pw[i]);
    }
    ret=ans,M=1,ans=0;
    return ret;
}
};

5.杜教筛

// luogu-judger-enable-o2
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize"Ofast"
#include <cstdio>
#include <cstring>
#include <algorithm>
#define NN 3001000
#define MM 3000100
#define maxn 3000000
#define ll long long 
#define uint unsigned int
#define mod 1000000007
using namespace std;

int N,K,l,r,sq,len;
namespace S1{
int pr[NN],use[NN],mu[NN],phi[NN],smu[NN],cnt;
ll sphi[NN];
void Pre()
{
    mu[1]=smu[1]=1,phi[1]=sphi[1]=1;
    for(int i=2;i<=maxn;i++)
    {
        if(!use[i]) pr[++cnt]=i,mu[i]=-1,phi[i]=i-1;
        smu[i]=smu[i-1]+mu[i],sphi[i]=sphi[i-1]+phi[i];
        for(int j=1;j<=cnt&&i*pr[j]<=maxn;j++){
            use[i*pr[j]]=1;
            if(i%pr[j]==0){
                mu[i*pr[j]]=0;
                phi[i*pr[j]]=phi[i]*pr[j];
                break;
            }else{
                mu[i*pr[j]]=-mu[i];
                phi[i*pr[j]]=phi[i]*phi[pr[j]];
            }
        }
    }
}
};
struct Chain{
    #define maxx 3000000
    int nxt[MM],head[MM],to[MM],cte;
    ll val[MM];
    void ae(int u,int v,ll w){
        cte++;to[cte]=v,val[cte]=w;
        nxt[cte]=head[u],head[u]=cte;
    }
    ll find(int U){
        int u=U%maxx;
        for(int j=head[u];j;j=nxt[j]){
            ll v=to[j];
            if(v==U) return val[j];
        }return -1;
    }
    void ins(int U,ll w){
        int u=U%maxx;
        ae(u,U,w);
    }
    #undef maxx
}mu,phi;
ll query_mu(int n)
{
    if(n<=maxn) return S1::smu[n];
    ll ans;
    ans=mu.find(n);
    if(ans!=-1) return ans;
    ans=1;
    for(int i=2,la;i<=n;i=la+1){
        la=n/(n/i);
        ans-=1ll*(la-i+1)*query_mu(n/i);
    }mu.ins(n,ans);
    return ans;
}
ll query_phi(int n)
{
    if(n<=maxn) return S1::sphi[n];
    ll ans;
    ans=phi.find(n);
    if(ans!=-1) return ans;
    ans=1ll*n*(n+1)/2;
    for(int i=2,la;i<=n;i=la+1){
        la=1ll*n/(n/i);
        ans-=1ll*(la-i+1)*query_phi(n/i);
    }phi.ins(n,ans);
    return ans;
}

int main()
{
    //freopen("t1.in","r",stdin);
    int T;ll n;
    S1::Pre();
    scanf("%d",&T);
    while(T--){
        scanf("%lld",&n);
        ll ans_mu=query_mu(n);
        ll ans_phi=query_phi(n);
        printf("%lld %lld
",ans_phi,ans_mu);
    }
    return 0;
}

6.矩阵求逆
在当前矩阵右侧补上一个等大的单位矩阵，然后跑高斯消元，右侧剩下的矩阵就是逆矩阵

高斯消元的思想比较简单，每次把第$i$列中的某一行$j$上的数$a_{ji}$变成1，然后根据等式的性质，把第$j$行后面的元素都除以$a_{ji}$

然后再把这个等式带入到其他行中，设法把这些行第$i$列上的数消去，变成0，还要对右面的元素也进行修改，保证等式成立

如果任何一行的第$i$列都是0，说明该方程无解，即逆矩阵不存在

struct M{
ll f[NN][NN*2]; 
int Gauss()
{
    for(int i=1;i<=n;i++)
        f[i][i+n]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=i;j<=n;j++)
        if(f[j][i]){
            for(int k=1;k<=nn;k++)
                swap(f[i][k],f[j][k]);
            break;
        }
        if(!f[i][i]) {return 0;}
        ll inv,y;exgcd(f[i][i],mod,inv,y);
        inv=(inv%mod+mod)%mod;
        for(int j=i;j<=nn;j++)
            f[i][j]=f[i][j]*inv%mod;
        for(int j=1;j<=n;j++)
        if(j!=i){
            y=f[j][i];
            for(int k=i;k<=nn;k++)
                f[j][k]=(f[j][k]-y*f[i][k]%mod+mod)%mod;
        }
    }return 1;
}
}m;