【模板（们）】noip前热身练习（更新中...）

分块+莫队

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
/*分块*/
#include<cmath>
const int N=;
int pos[N],n,blk;
void fenkuai(){
    scanf("%d",&n);
    blk=(int)(double(n));
    for(int i=;i<=n;i++) pos[i]=(i-)/blk+;
}
/*莫队*/
int ans=;
struct qujian{
    int le,ri,ans;
}q[N];
bool cmp(const qujian &a,const qujian &b){
    return pos[a.le]<pos[b.le]||(pos[a.le]==pos[b.le]&&a.ri<b.ri);
}
void update(int pos,int val){
}
void modui(){
    scanf("%d",&n);
    fenkuai();
    for(int i=;i<=n;i++) scanf("%d%d",&q[i].le,&q[i].ri);
    sort(q+,q+n+,cmp);
    int le,ri;
    le=ri=;
    for(int i=;i<=n;i++){
        while(ri>q[i].ri){
            update(ri,-);
            ri--;
        }
        while(ri<q[i].ri){
            update(ri+,);
            ri++;
        }
        while(le<q[i].le){
            update(le,-);
            le++;
        }
        while(le>q[i].le){
            update(le-,);
            le--;
        }
        q[i].ans=ans;
    }
    /*...*/
}

分块+莫队

字符串：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=;

/*kmp*/
int lens,lenp,nxt[N];
char s[N],p[N];
void get_nxt(){
    int i=,j=-;
    nxt[]=-;
    while(i<lenp){
        if(j==-||p[i]==p[j]){
            i++,j++;
            nxt[i]=j;
        }
        else j=nxt[j];
    }
}
void kmp(){
    int i=,j=;
    while(i<lens){
        if(j==-||s[i]==p[j]){
            i++,j++;
            if(j==lenp){
                /*success*/
                j=nxt[j];
            }
        }
        else j=nxt[j];
    }
}
int main(){
    scanf("%s%s",s,p);
    lens=strlen(s),lenp=strlen(p);
    get_nxt();
    kmp();
    return ;
}

/*manacher*/
int pal[N];
void fixs(){
    /* "aba" -> "-#a#b#a#+" */
}
void manacher(){
    int id,mx=;
    for(int i=;i<=lens;i++){
        if(mx>=i) pal[i]=min(pal[*id-i],mx-i+);
        //else pal[i]=1;
        while(s[i+pal[i]]==s[i-pal[i]]) pal[i]++;
        if(pal[i]>mx) mx=pal[i],id=i;
    }
}
int main(){
    scanf("%s",s);
    lens=strlen(s);
    fixs();
    manacher();
    return ;
}

kmp+manacher

数据结构

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=;

/*左偏树(大根堆) + 并查集(路径压缩) */
int n,fa[N];
struct node{
    int ls,rs;
    int dis,key;
}tr[N];
int getfa(int x){
    if(fa[x]==x) return x;
    return fa[x]=getfa(fa[x]);
}
int merge(int a,int b){
    if(a==) return b;
    if(b==) return a;
    if(tr[a].key<tr[b].key) swap(a,b);
    tr[a].rs=merge(tr[a].rs,b);
    if(tr[tr[a].ls].dis<tr[tr[a].rs].dis) swap(tr[a].ls,tr[a].rs);
    tr[a].dis=tr[tr[a].rs].dis+;
    return a;
}
int del(int a){
    int tmp=merge(tr[a].ls,tr[a].rs);
    fa[getfa(a)]=tmp;
    fa[fa[getfa(a)]]=tmp;
    return tmp;
}
int main(){
    tr[].dis=-,tr[].key=;//(small heap)tr[0].key=INF;
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d",&tr[i].key);
    for(int i=;i<=n;i++) fa[i]=i;
    int q,opt,x,y;
    scanf("%d",&q);
    while(q--){
        scanf("%d",&opt);
        if(opt==){
            scanf("%d%d",&x,&y);
            if(getfa(x)==getfa(y)) continue;
            int tmp=merge(getfa(x),getfa(y));
            fa[getfa(x)]=fa[getfa(y)]=tmp;
            printf("%d\n",tmp);
        }
        else{
            scanf("%d",&x);
            printf("%d\n",del(getfa(x)));
        }
    }
    return ;
} 

可并堆（左偏树）

#include<queue>
struct cmp{
    bool operator()(const Type &_a,const Type &_b){
        return _a>_b;//小根堆
    }
};
priority_queue<Type,vector<Type>,cmp> q;

优先队列STL（堆）

图论

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=+;
/*dijkstra(spfa)+heap(曾一直以为是spfa)*/
int s=,n,m,dis[N];
bool exi[N];
int head[N],to[N*],val[N*],nxt[N*],hh=;
struct cmp{
    bool operator()(const int &a,const int &b){
        return dis[a]>dis[b];
    }
};
priority_queue<int,vector<int>,cmp> q;
void spfa(){
    memset(dis,0x3f,sizeof(dis));
    memset(exi,,sizeof(exi));
    while(!q.empty()) q.pop();
    dis[s]=,exi[s]=;
    q.push(s);
    while(!q.empty()){
        int u=q.top();q.pop();
        exi[u]=;
        for(int i=head[u];i;i=nxt[i]){
            int v=to[i];
            if(dis[v]>dis[u]+val[i]){
                dis[v]=dis[u]+val[i];
                if(!exi[v]){
                    q.push(v);
                    exi[v]=;
                }
            }
        }
    }
}
void adde(int a,int b,int v){
    hh++;
    to[hh]=b;
    val[hh]=v;
    nxt[hh]=head[a];
    head[a]=hh;
}
int main(){
    scanf("%d%d",&n,&m);
    int u,v,w;
    for(int i=;i<=m;i++){
        scanf("%d%d%d",&u,&v,&w);
        adde(u,v,w),adde(v,u,w);
    }
    spfa();
    for(int i=;i<=n;i++) printf("%d ",dis[i]);
    return ;
}

dijkstra+heap

bool find(int u){
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(vis[v]) continue;
        vis[v]=;
        if(bl[v]==||find(bl[v])){
            bl[v]=u;
            return true;
        }
    }
    return false;
}
int main(){
    /*...*/
    int cnt=;
    for(int i=;i<=n;i++){
        memset(vis,,sizeof(vis));//可用时间戳优化
        if(find(i)) cnt++;
    }
    /*...*/
} 

匈牙利算法

数论

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}
void exgcd(int a,int b,int &x,int &y){
    if(b==){
        x=,y=;return;
    }
    int x0,y0;
    exgcd(b,a%b,x0,y0);
    x=y0;
    y=x0-(a/b)*y0;
}

gcd+exgcd

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=;

/*线性筛(莫比乌斯函数+欧拉函数)*/
int n;
int prime[N],cntp,phi[N],mui[N];
bool notp[N];
void init(){
    notp[]=;
    phi[]=,mui[]=;
    for(int i=;i<=n;i++){
        if(!notp[i]){
            prime[++cntp]=i;
            phi[i]=i-;
            mui[i]=-;
        }
        for(int j=;j<=cntp&&i*prime[j]<=n;j++){
            if(i%prime[j]==){
                phi[i*prime[j]]=phi[i]*prime[j];
                mui[i*prime[j]]=;
                break;
            }
            phi[i*prime[j]]=phi[i]*(prime[j]-);
            mui[i*prime[j]]=-mui[i];
            notp[i*prime[j]]=;
        }
    }
}

/*高斯消元*/
#include<cmath>
const double eps=1e-;
int n,m;//n项 m方程
double g[N][N],ans[N];
void gauss(){
    int cnt=;
    for(int k=;k<=n;k++){//第k列
        int j=-;
        for(int i=cnt+;i<=m;i++) if(fabs(g[i][k])>eps){
            j=i;break;
        }
        if(j==-) continue;
        for(int i=;i<=n+;i++) swap(g[cnt+][i],g[j][i]);
        for(j=;j<=m;j++){
            if(j==cnt+) continue;//!
            if(fabs(g[j][k])<eps) continue;
            double r=g[j][k]/g[cnt+][k];
            for(int i=;i<=n+;i++)
                g[j][i]-=r*g[cnt+][i];
        }
        cnt++;
    }
    for(int i=cnt+;i<=m;i++){
        if(fabs(g[i][n+])>eps)
            printf("no solution!\n");
    }
    if(cnt<n){
        printf("more than one solution!\n");
        return;
    }
    for(int i=;i<=cnt;i++)
        ans[i]=g[i][n+]/g[i][i];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=;i<=m;i++)
        for(int j=;j<=n+;j++) scanf("%lf",&g[i][j]);
    gauss();
    for(int i=;i<=n;i++) printf("%.2lf ",ans[i]);
    return ;
}

线性筛（基本积性函数）+高斯消元

Type power(Type a,Type b){
    Type rt=;
    for(;b;b>>=,a=a*a%mod) if(b&) rt=rt*a%mod;
    return rt;
} 

快速幂

dp

int dfs(int pos,/*int some_ifo,*/bool limit/*,bool zero*/){
    if(pos==) return ;
    if((!limit)/*&&(!zero)*/&&f[pos]!=-) return f[pos];
    int st=limit?k[pos]:;
    int ans=;
    for(int i=;i<=st;i++){
        /*if(some_limit)*/ ans+=dfs(pos-,/**/,limit&&i==st/*,zero&&i==0*/);
    }
    if((!limit)/*&&(!zero)*/) f[pos]=ans;
    return ans;
}

数位dp

高精度

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=+;

struct Type{
    int a[N],len;
};
void read(Type &res){
    char ch=;
    res.a[]=,res.len=;
    while(ch<''||ch>''){if(ch=='-')res.a[]=-;ch=getchar();}
    while(ch>=''&&ch<=''){res.a[++res.len]=ch-'';ch=getchar();}
    for(int i=;i<=res.len/;i++) swap(res.a[i],res.a[res.len-i+]);
}
void print(const Type &pr){
    if(pr.a[]==-) printf("-");
    for(int i=pr.len;i>=;i--) printf("%d",pr.a[i]);
}
Type operator +(Type _a,Type _b){
    Type _c;
    _c.len=max(_a.len,_b.len);
    int tmp=;
    for(int i=;i<=min(_a.len,_b.len);i++){
        tmp=_a.a[i]+_b.a[i]+tmp;
        _c.a[i]=tmp%;
        tmp/=;
    }
    for(int i=min(_a.len,_b.len)+;i<=_c.len;i++){
        tmp=_a.len>_b.len?_a.a[i]+tmp:_b.a[i]+tmp;
        _c.a[i]=tmp%;
        tmp/=;
    }
    if(tmp) _c.a[++_c.len]=tmp;
    return _c;
}
Type operator -(Type _a,Type _b){
    Type _c;
    _c.len=_a.len;
    for(int i=;i<=_b.len;i++){
        _c.a[i]=_a.a[i]-_b.a[i];
        if(_c.a[i]<) _c.a[i]+=,_a.a[i+]--;
    }
    for(int i=_b.len+;i<=_a.len;i++) _c.a[i]=_a.a[i];
    while(_c.a[_c.len]==) _c.len--;
    return _c;
}
Type a,b;
int main(){
    read(a),read(b);
    print(a-b);
    return ;
}

高精度加减