C++各种模板

高精度：

重载运算符版：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int NR=1e4;
char s[NR];
struct Bigint
{
    int num[NR];
    Bigint()
    {
        memset(num,,sizeof(num));
        num[]=;
    }
    void read()
    {
        scanf("%s",s);
        num[]=strlen(s);
        for(int i=;i<=num[];i++)
            num[i]=s[num[]-i]-'';
    }
    void print()
    {
        for(int i=num[];i>=;i--)
            printf("%d",num[i]);
        puts("");
    }
    Bigint operator + (const Bigint &B) const
    {
        Bigint c;
        c.num[]=max(num[],B.num[]);
        for(int i=;i<=c.num[];i++)
        {
            c.num[i]+=num[i]+B.num[i];
            c.num[i+]+=c.num[i]/;
            c.num[i]%=;
        }
        if(c.num[c.num[]+]>)
            c.num[]++;
        return c;
    }
};
int main(void)
{
    Bigint a,b,c;
    a.read();
    b.read();
    c=a+b;
    c.print();
    return ;
}

普通高精度：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int NR=1e3;
char s[NR+];
int a[NR+],b[NR+],c[NR+];
void read(int a[])
{
    scanf("%s",s);
    a[]=strlen(s);
    for(int i=;i<=a[];i++)
        a[i]=s[a[]-i]-'';
}
void print(int a[])
{
    for(int i=a[];i>=;i--)
        printf("%d",a[i]);
    puts("");
}
void add(int a[],int b[],int c[])
{
    c[]=max(a[],b[]);
    for(int i=;i<=c[];i++)
    {
        c[i]+=a[i]+b[i];
        c[i+]=c[i]/;
        c[i]%=;
    }
    if(c[c[]+]>)
        printf("%d",c[c[]]+);
}
int main()
{
    read(a);
    read(b);
    add(a,b,c);
    print(c);
    return ;
}

快速幂：

#include<cstdio>
#include<algorithm>
using namespace std;
long long po(long long x,long long p,long long k)
{
    if(p==)
        return ;
    if(p==)
        return x;
    int a=po(x,p/,k);
    a%=k;
    if(p%==)
        return (a*a)%k;
    return (a*a*x)%k;
}
int main(void)
{
    long long x,p,k;
    scanf("%lld%lld%lld",&x,&p,&k);
    printf("%lld^%lld mod %lld=%lld\n",x,p,k,po(x,p,k)%k);
    return ;
}

判断回文数：

#include<cstdio>
using namespace std;
int num[],len;
bool check(int x)
{
    int tmp=;
    while(x!=)
    {
        num[++tmp]=x%;
        x/=;
        len++;
    }
    for(int i=;i<=len/;i++)
        if(num[i]!=num[len+-i])
            return false;
    return true;
}
int main()
{
    int n;
    scanf("%d",&n);
    if(check(n)==true)
        printf("YES\n");
    else
        printf("NO\n");
    return ;
}

并查集：

#include<cstdio>
#include<algorithm>
using namespace std;
const int NR=1e5;
int n,m;
int bin[NR+],tot;
int anc(int x)
{
    if(bin[x]==)
        return x;
    bin[x]=anc(bin[x]);
    return bin[x];
}
void link(int u,int v)
{
    u=anc(u);
    v=anc(v);
    if(u!=v)
    {
        bin[u]=v;
        tot--;
    }
}
struct road
{
    int x,y,t;
    void inp()
    {
        scanf("%d%d%d",&x,&y,&t);
    }
    friend bool operator < (road A,road B)
    {
        return A.t<B.t;
    }
};
road s[NR+];
void inp()
{
    scanf("%d%d",&n,&m);
    for(int i=;i<=m;i++)
        s[i].inp();
    tot=n;
}
void ask(int u,int v)
{
    if(anc(u)==anc(v))
        printf("Yes\n");
    else
        printf("No\n");
}
void calc()
{
    sort(s+,s+m+);
    int i;
    for(i=;i<=m;i++)
    {
        link(s[i].x,s[i].y);
        if(tot==)
            goto finish;
    }
    printf("-1\n");
    return;
    finish:
    printf("%d\n",s[i].t);
}
int main(void)
{
    inp();
    calc();
    return ;
}

归并排序：

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int NR=5e5;
int n;
int a[NR+],tmp[NR+];
void marge(int l,int r,int mid)
{
    int sum=r-l+,t=;
    int disl=l,disr=mid+;
    while(disl<=mid&&disr<=r)
    {
        if(a[disl]>a[disr])
        {
            t++;
            tmp[t]=a[disr];
            disr++;
        }
        else
        {
            t++;
            tmp[t]=a[disl];
            disl++;
        }
    }
    while(disl<=mid)
    {
        t++;
        tmp[t]=a[disl];
        disl++;
    }
    while(disr<=r)
    {
        t++;
        tmp[t]=a[disr];
        disr++;
    }
    for(int i=;i<=sum;i++)
        a[l+i-]=tmp[i];
    return;
}
void cha(int l,int r)
{
    if(l==r)
        return;
    int mid=(l+r)>>;
    cha(l,mid);
    cha(mid+,r);
    marge(l,r,mid);
    return;
}
int main(void)
{
    scanf("%d",&n);
    for(int i=;i<=n;i++)
        scanf("%d",&a[i]);
    cha(,n);
    for(int i=;i<=n;i++)
        printf("%lld ",a[i]);
    puts("");
    return ;
}

进制转换：

#include<cstdio>
#include<algorithm>
using namespace std;
int len[],tmp=;
void change(int n,int a,int b)
{
    int n_10=;
    int fu=n;
    while(fu)
    {
        n_10+=fu%*tmp;
        tmp*=a;
        fu/=;
    }
    fu=n_10;
    tmp=;
    while(fu)
    {
        len[++tmp]=fu%b;
        fu/=b;
    }
}
int main()
{
    int n,a,b;
    scanf("%d%d%d",&n,&a,&b);
    change(n,a,b);
    for(int i=tmp;i>=;i--)
        printf("%d",len[i]);
    puts("");
    return ;
}

逆元：

#include<cstdio>
#include<algorithm>
using namespace std;
int main(void)
{
    int p;
    scanf("%d",&p);
    int inv[p+];
    inv[]=;
    for(int i=;i<=p-;i++)
        inv[i]=(p-p/i)*inv[p%i]%p;
    for(int i=;i<=p-;i++)
        printf("%d\n",inv[i]);
    return ;
}

分解质因数：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int p[];
int factor(int x,int p[])
{
    int cnt=;
    for(int i=;i*i<=x;i++)
        while(x%i==)
        {
            p[++cnt]=i;
            x/=i;
        }
    if(x>)
        p[++cnt]=x;
    return cnt;
}
int main(void)
{
    int n;
    scanf("%d",&n);
    printf("%d\n",factor(n,p));
    return ;
}

二叉搜索树：

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int NR=1e5;
struct note
{
    int val,w;
    int lc,rc;
}T[NR+];
int n,cnt,a[NR+];
void ins(int o,int v)
{
    if(!T[o].val)
    {
        T[o].val=v;
        T[o].w++;
        return;
    }
    if(T[o].val==v)
    {
        T[o].val++;
        return;
    }
    if(v<T[o].val)
    {
        if(!T[o].lc)
            T[o].lc=++cnt;
        ins(T[o].lc,v);
    }
    if(v>T[o].val)
    {
        if(!T[o].rc)
            T[o].rc=++cnt;
        ins(T[o].rc,v);
    }
}
void dfs(int o)
{
    if(!T[o].val)
        return;
    if(T[o].lc)
        dfs(T[o].lc);
    printf("%d ",T[o].val);
    if(T[o].rc)
        dfs(T[o].rc);
}
int main(void)
{
    scanf("%d",&n);
    cnt=;
    for(int i=;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=;i<=n;i++)
        ins(,a[i]);
    dfs();
    puts("");
    return ;
}

线性筛：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main(void)
{
    int n=;
    bool flag[];
    memset(flag,false,sizeof(flag));
    for(int i=;i<=;i++)
        if(flag[i]==false)
        {
            printf("%d\n",i);
            for(int j=;i*j<=n;j++)
                flag[i*j]=true;
        }
    return ;
}

裴蜀定理：

#include<cstdio>
#include<algorithm>
using namespace std;
#define pr pair<int,int>
#define x tmp.first;
#define y tmp.second;
pr exged(int a,int b)
{
    if(b==)
        return pr(,);
    pr tmp=exged(b,a%b);
    return pr(y,x-a/b*y);
}
int main(void)
{

    return ;
}

哈希碰撞：

#include<cstdio>
#include<algorithm>
using namespace std;
struct brute
{
    bool w[];
    void ins(int x)
    {
        w[x]=;
    }
    void ask(int x)
    {
        printf("%d\n",w[x]);
    }
}
#define ha 233333;
struct naive
{
    bool w[ha+];
    void ins(int x)
    {
        w[x%ha]=;
    }
    void ask(int x)
    {
        printf("%d\n",w[x%ha]);
    }
};
/*naive B;
struct zip
{
    vector<bool> w[ha+5];
    void ins(int x)
    {
        w[x%ha]
    }
};*/
int main(void)
{

    return ;
}

测空间：

#include<cstdio>
#include<algorithm>
using namespace std;
int a[];
int main(void)
{
    int sum=sizeof(a);
    printf("%d\n",sum//);
    return ;
}

一行gcd :

int gcd(int a,int b){  return b ? gcd(b,a%b) : a;}

线段树模板：

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define ll long long
const int NR=1e6;
unsigned ll n,m,a[NR+],ans[*NR+],tag[NR*+];
inline ll ls(ll x)
{
    return x<<;
}
inline ll rs(ll x)
{
    return x<<|;
}
void scan()
{
    scanf("%lld%lld",&n,&m);
    for(ll i=;i<=n;i++)
        scanf("%lld",&a[i]);
}
inline void push_up(ll p)
{
    ans[p]=ans[ls(p)]+ans[rs(p)];
}
void build(ll p,ll l,ll r)
{
    tag[p]=;
    if(l==r)
    {
        ans[p]=a[l];
        return;
    }
    ll mid=(l+r)>>;
    build(ls(p),l,mid);
    build(rs(p),mid+,r);
    push_up(p);
}
inline void f(ll p,ll l,ll r,ll k)
{
    tag[p]=tag[p]+k;
    ans[p]=ans[p]+k*(r-l+);
}
inline void push_down(ll p,ll l,ll r)
{
    ll mid=(l+r)>>;
    f(ls(p),l,mid,tag[p]);
    f(rs(p),mid+,r,tag[p]);
    tag[p]=;
}
inline void update(ll nl,ll nr,ll l,ll r,ll p,ll k)
{
    if(nl<=l&&r<=nr)
    {
        ans[p]+=k*(r-l+);
        tag[p]+=k;
        return;
    }
    push_down(p,l,r);
    ll mid=(l+r)>>;
    if(nl<=mid)
        update(nl,nr,l,mid,ls(p),k);
    if(nr>mid)
        update(nl,nr,mid+,r,rs(p),k);
    push_up(p);
}
ll query(ll q_x,ll q_y,ll l,ll r,ll p)
{
    ll res=;
    if(q_x<=l&&q_y>=r)
        return ans[p];
    ll mid=(l+r)>>;
    push_down(p,l,r);
    if(q_x<=mid)
        res+=query(q_x,q_y,l,mid,ls(p));
    if(q_y>mid)
        res+=query(q_x,q_y,mid+,r,rs(p));
    return res;
}
int main(void)
{
    ll a1,b,c,d,e,f;
    scan();
    build(,,n);
    while(m--)
    {
        scanf("%lld",&a1);
        switch(a1)
        {
            case :
            {
                scanf("%lld%lld%lld",&b,&c,&d);
                update(b,c,,n,,d);
                break;
            }
            case :
            {
                scanf("%lld%lld",&e,&f);
                printf("%lld\n",query(e,f,,n,));
                break;
            }
        }
    }
    return ;
}