模板集合——持续更新中

首先  

sro_Cydiater_orz  

sro_姬树流_orz

两位开搞模板集合已久的大神

1、对拍

@echo off
set path=C:MinGWStudioMinGWin
g++ -o makedata.exe makedata.cpp
g++ -o right.exe right.cpp
g++ -o test.exe test.cpp
set path=C:Windowssystem32
:loop
makedata.exe
right.exe
test.exe
fc cout1.out cout2.out
if errorlevel==1 pause
goto loop

2、fread

char buf[1<<15],*fs,*ft;
inline char getc() {return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;}
inline int read()
{
    int x=0,f=1;  char ch=getc();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getc();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getc();}
    return x*f;
}

3、fwrite

char buf[1<<15],*fs=buf,*ft=buf+(1<<15);
#define ot(x) (fs==ft?fwrite(buf,1,1<<15,stdout),*(fs=buf)++=x:*fs++=x)
inline void print(int x)
{
    if(x<0) {ot(45);x=-x;}
    static char s[15],*b; b=s;
    if(!x)*b++=48;
    for(;x;*b++=x%10+48,x/=10);
    for(;b--!=s;ot(*b));
}

4、倍增求LCA

void dfs(int x,int fa)
{
    anc[x][0]=f[x];
    for(int i=1;i<=20;i++)  anc[x][i]=anc[anc[x][i-1]][i-1];
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa)
        {
            f[e[i].y]=x;
            deep[e[i].y]=deep[x]+1;
            dfs(e[i].y,x);
        }
}
int lca(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    for(int i=20;i>=0;i--) if(deep[anc[x][i]]>=deep[y])  x=anc[x][i];
    if(x==y) return x;
    for(int i=20;i>=0;i--) if(anc[x][i]!=anc[y][i])  x=anc[x][i],y=anc[y][i];
    return f[x];
}

5、树链剖分

void dfs1(int x)
{
    dep[x]=dep[f[x]]+1;  size[x]=1;
    for(int i=a[x];i;i=e[i].next)
        if(e[i].y!=f[x]&&!f[e[i].y])
        {
            f[e[i].y]=x;
            dfs1(e[i].y);
            size[x]+=size[e[i].y];
            if(size[son[x]]<size[e[i].y])  son[x]=e[i].y;
        }
}
void dfs2(int x)
{
    if(x==son[f[x]])top[x]=top[f[x]]; else top[x]=x;
    for(int i=a[x];i;i=e[i].next) if(f[e[i].y]==x)  dfs2(e[i].y);
}

6、Treap

struct data{int l,r,v,size,fix,w;}tr[100005];
int n,len,root,ans;
void update(int k){tr[k].size=tr[tr[k].l].size+tr[tr[k].r].size+tr[k].w;}
void rturn(int &k){int t=tr[k].l;tr[k].l=tr[t].r;tr[t].r=k;tr[t].size=tr[k].size;update(k);k=t;}
void lturn(int &k){int t=tr[k].r;tr[k].r=tr[t].l;tr[t].l=k;tr[t].size=tr[k].size;update(k);k=t;}
void insert(int &k,int x)
{
    if(k==0){len++;k=len;tr[k].size=tr[k].w=1;tr[k].v=x;tr[k].fix=rand();return;}
    tr[k].size++;
    if(tr[k].v==x)tr[k].w++;//每个结点顺便记录下与该节点相同值的数的个数
    else if(x>tr[k].v){insert(tr[k].r,x);if(tr[tr[k].r].fix<tr[k].fix)lturn(k);}
    else {insert(tr[k].l,x);if(tr[tr[k].l].fix<tr[k].fix)rturn(k);} 
}
void del(int &k,int x)
{
    if(k==0)return; 
    if(tr[k].v==x)
    {
        if(tr[k].w>1){tr[k].w--;tr[k].size--;return;}
        if(tr[k].l*tr[k].r==0)k=tr[k].l+tr[k].r;//有一个儿子为空
        else if(tr[tr[k].l].fix<tr[tr[k].r].fix) rturn(k),del(k,x);
        else lturn(k),del(k,x);
    }
    else if(x>tr[k].v) tr[k].size--,del(tr[k].r,x);
    else tr[k].size--,del(tr[k].l,x);
}
int rank(int k,int x)
{
    if(k==0) return 0;
    if(tr[k].v==x) return tr[tr[k].l].size+1;
    else if(x>tr[k].v) return tr[tr[k].l].size+tr[k].w+rank(tr[k].r,x);
    else return rank(tr[k].l,x);
}
int Findkth(int k,int x)
{
    if(k==0)return 0;
    if(x<=tr[tr[k].l].size) return Findkth(tr[k].l,x);
    else if(x>tr[tr[k].l].size+tr[k].w) return Findkth(tr[k].r,x-tr[tr[k].l].size-tr[k].w);
    else return tr[k].v;
}
void get_before(int k,int x)
{
    if(k==0)return;
    if(tr[k].v<x) ans=k;get_before(tr[k].r,x);
    else get_before(tr[k].l,x);
}
void get_behind(int k,int x)
{
    if(k==0)return;
    if(tr[k].v>x) ans=k;get_behind(tr[k].l,x);
    else get_behind(tr[k].r,x);
}

7、替罪羊树

#define INF 1000000000
const double chty=0.75;  //平衡常数
struct node{int son[2],f,size,v;}tr[100005];
int n,len,root,top,stack[100005];
void init()
{
    len=2;  root=1;
    tr[1].size=2;  tr[1].v=-INF;  tr[1].son[1]=2;
    tr[2].size=1;  tr[2].v=INF;   tr[2].f=1;
}
bool balance(int x) 
{
    double p=tr[x].size*chty;
    return p>=(double)tr[tr[x].son[0]].size&&p>=(double)tr[tr[x].son[1]].size;
}
void dfs(int x)//中序遍历
{
    if(!x)  return;
    dfs(tr[x].son[0]);
    stack[++top]=x;
    dfs(tr[x].son[1]);
}
int build(int l,int r)
{
    if(l>r)  return 0;
    int mid=(l+r)/2,x=stack[mid];
    tr[tr[x].son[0]=build(l,mid-1)].f=x;
    tr[tr[x].son[1]=build(mid+1,r)].f=x;
    tr[x].size=tr[tr[x].son[0]].size+tr[tr[x].son[1]].size+1;
    return x;
}
void rebuild(int x)
{
    top=0;  dfs(x);
    int fa=tr[x].f,which=(tr[fa].son[1]==x);
    int sonroot=build(1,top);
    tr[tr[fa].son[which]=sonroot].f=fa;
    if(x==root)  root=sonroot;
}
int find(int v)
{
    int now=root;
    while(now)
    {
        if(v==tr[now].v)  return now;
        else now=tr[now].son[v>tr[now].v];
    }
}
void insert(int v)
{
    int now=root,p=++len; 
    tr[p].v=v;  tr[p].size=1;//新开结点
    while(1)
    {
        tr[now].size++;
        int which=(v>=tr[now].v);//表示p在当前根的哪个子树内
        if(tr[now].son[which])  now=tr[now].son[which];  
        else {tr[tr[now].son[which]=p].f=now;  break;}
    }
    int id=0;
    for(int i=p;i;i=tr[i].f)  if(!balance(i))  id=i;//记录不平衡点
    if(id)  rebuild(id);//重构子树
}
void del(int x)
{
    if(tr[x].son[0]&&tr[x].son[1])
    {
        int p=tr[x].son[0];
        while(tr[p].son[1])  p=tr[p].son[1];
        tr[x].v=tr[p].v;  x=p;
    }
    int Son=(tr[x].son[0])?tr[x].son[0]:tr[x].son[1],which=(tr[tr[x].f].son[1]==x);
    tr[tr[tr[x].f].son[which]=Son].f=tr[x].f;
    for(int i=tr[x].f;i;i=tr[i].f)  tr[i].size--;
    if(x==root)  root=Son;
}
int rank(int v)
{
    int now=root,ans=0;
    while(now)
    {
        if(tr[now].v<v)  {ans+=tr[tr[now].son[0]].size+1;  now=tr[now].son[1];}
        else now=tr[now].son[0];
    }
    return ans;
}
int kth(int x)
{
    int now=root;
    while(1)
    {
        if(tr[tr[now].son[0]].size==x-1)  return now;
        else if(tr[tr[now].son[0]].size>=x)  now=tr[now].son[0];
        else x-=tr[tr[now].son[0]].size+1,now=tr[now].son[1];
    }
    return now;
}
int before(int v)
{
    int now=root,ans=-INF;
    while(now)
    {
        if(tr[now].v<v)  ans=max(ans,tr[now].v),now=tr[now].son[1];
        else now=tr[now].son[0];
    }
    return ans;
}
int after(int v)
{
    int now=root,ans=INF;
    while(now)
    {
        if(tr[now].v>v)  ans=min(ans,tr[now].v),now=tr[now].son[0];
        else now=tr[now].son[1];
    }
    return ans;
}

8、kmp

void pre(){int j=0;for(int i=2;i<=m;i++){while(j>0&&b[j+1]!=b[i])j=p[j];if(b[j+1]==b[i])j++;p[i]=j;}}
void kmp(){int j=0;for(int i=1;i<=n;i++){while(j>0&&b[j+1]!=a[i])j=p[j];if(b[j+1]==a[i])j++;if(j==m)printf("%d
",i-m+1);}

9、AC自动机

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<iomanip>
using namespace std;
#define MAXN 1000100
int n,cnt,q[MAXN],fail[MAXN],end[MAXN],tr[MAXN][26];
char ch[MAXN];
void insert()
{
    int now=0;
    for(int i=1;i<=strlen(ch+1);i++)
    {
        if(!tr[now][ch[i]-'a']) tr[now][ch[i]-'a']=++cnt;
        now=tr[now][ch[i]-'a'];
    }
    end[now]++;
}
void build()
{
    int head=0,tail=0;
    for(int i=0;i<26;i++)  if(tr[0][i])  q[++tail]=tr[0][i];
    while(++head<=tail)
    {
        int x=q[head];
        for(int i=0;i<26;i++)
        {
            if(!tr[x][i])  tr[x][i]=tr[fail[x]][i];
            else fail[tr[x][i]]=tr[fail[x]][i],q[++tail]=tr[x][i];
        }
    }
}
void find()
{
    scanf("%s",ch+1);  int x=0,ans=0;
    for(int i=1;i<=strlen(ch+1);i++)
    {
        while(x&&!tr[x][ch[i]-'a'])x=fail[x]; x=tr[x][ch[i]-'a']; int temp=x;
        while(temp){ans+=end[temp];temp=fail[temp];}
    }
    printf("%d
",ans);
}
int main()
{
    freopen("cin.in","r",stdin);
    freopen("cout.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {scanf("%s",ch+1); insert();}
    build();
    find();
    return 0;
}

10、后缀数组

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
using namespace std;
#define FILE "read"
#define MAXN 100010
int n,rank[MAXN],sa[MAXN],p[MAXN],cnt[MAXN],tmp[MAXN],height[MAXN];
char s[MAXN];
namespace Suffix_Array{
    bool equ(int x,int y,int l) {return rank[x]==rank[y]&&rank[x+l]==rank[y+l];}
    void doubling(){
        for(int i=1;i<=n;i++)  rank[i]=s[i],sa[i]=i;
        for(int pos=0,l=0,i,sig=255;pos<n;sig=pos){
            for(i=n-l+1,pos=0;i<=n;i++)  p[++pos]=i;
            for(i=1;i<=n;i++) if(sa[i]>l)  p[++pos]=sa[i]-l;
            for(i=1;i<=sig;i++)  cnt[i]=0;
            for(i=1;i<=n;i++)  cnt[rank[i]]++;
            for(i=1;i<=sig;i++)  cnt[i]+=cnt[i-1];
            for(i=n;i;i--)  sa[cnt[rank[p[i]]]--]=p[i];
            for(i=1,pos=0;i<=n;i++)  tmp[sa[i]]=equ(sa[i],sa[i-1],l)?pos:++pos;
            l=!l?1:l<<1;
        }
    }
    void gethight(){
        for(int i=1,j=0,k;i<=n;i++){
            if(!(k=sa[rank[i]-1]))  {j=0;  continue;}
            if(j) j--;
            while(s[i+j]==s[k+j])  j++;
            height[rank[i]]=j;
        }
    }
}

11、归并排序

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
using namespace std;
#define FILE "read"
#define up(i,j,n) for(int i=j;i<=n;i++)
int n,a[10010];
namespace Init{
    char buf[1<<15],*fs,*ft;
    inline char getc() {return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;}
    inline int read(){
        int x=0,f=1;  char ch=getc();
        while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getc();}
        while(isdigit(ch))  {x=x*10+ch-'0';  ch=getc();}
        return x*f;
    }
}
namespace GB_Sort{
    int c[10010],len(0);
    void dfs2(int l,int r){
        int mid=(l+r)>>1,i=l,j=mid+1,len=l-1;
        while(i<=mid&&j<=r){
            if(a[i]>a[j])  c[++len]=a[j++];
            else c[++len]=a[i++];
        } 
        while(i<=mid)  c[++len]=a[i++];
        while(j<=r)  c[++len]=a[j++];
        up(i,l,r) a[i]=c[i];
    }
    void dfs1(int l,int r){
        if(l<r){
            int mid=(l+r)>>1;
            dfs1(l,mid);  dfs1(mid+1,r);
            dfs2(l,r);
        }
    }
}
void init(){
    n=Init::read();
    up(i,1,n) a[i]=Init::read();
}
void output() {up(i,1,n) printf("%d ",a[i]);  printf("
%d
",ans);}
int main(){
    freopen(FILE".in","r",stdin);
    freopen(FILE".out","w",stdout);
    init();
    GB_Sort::dfs1(1,n);
    output();
    return 0;
}

12、高精度

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<ctime>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long long ll;
#define FILE "read"
#define up(i,j,n) for(ll i=j;i<=n;i++)
#define down(i,j,n) for(ll i=j;i>=n;i--)
struct node{ll num[20010],len;}A,B;
char ch1[20010],ch2[20010];
namespace High{
    node add(node a,node b){//高精度加法
        ll len=max(a.len,b.len);
        node c;
        up(i,1,len){
            c.num[i]+=a.num[i]+b.num[i];
            while(c.num[i]>=10)  c.num[i+1]++,c.num[i]-=10;
        }
        while(c.num[len+1]>0)  len++;
        c.len=len;
        return c;
    }
    ll comp(node a,node b){//高精度数比较
        if(a.len>b.len) return -1;
        if(a.len<b.len) return 1;
        down(i,a.len,1){
            if(a.num[i]>b.num[i])  return -1;
            if(a.num[i]<b.num[i])  return 1;
        }
        return 0;
    }
    node Del(node a,node b){//高精度减法
        node c;
        ll len=max(a.len,b.len);
        up(i,1,len){
            c.num[i]+=a.num[i]-b.num[i];
            if(c.num[i]<0)  c.num[i]+=10,c.num[i+1]--;
        }
        while(c.num[len]==0&&len>1)  len--;
        c.len=len;
        return c;
    }
    node del(node a,node b){
        if(comp(a,b)>0)  {printf("-");  return Del(b,a);}
        else return Del(a,b);
    }
    node mul(node a,ll b){//高精乘单精
        node c;  ll len=a.len;
        memset(c.num,0,sizeof(c.num));
        up(i,1,len){
            c.num[i]+=a.num[i]*b;
            if(c.num[i]>=10) c.num[i+1]=c.num[i]/10,c.num[i]%=10;
        }
        while(c.num[len+1]){
            len++;
            if(c.num[len]>=10)  c.num[len+1]=c.num[len]/10,c.num[len]%=10;
        }
        c.len=len;
        return c;
    }
    node Mul(node a,node b){//高精乘高精
        node c; c.len=1;
        up(i,1,a.len)  up(j,1,b.len){
            ll k=i+j-1;
            c.num[k]+=a.num[i]*b.num[j];
            while(c.num[k]>=10)  c.num[k+1]+=c.num[k]/10,c.num[k]%=10,k++;
            if(k>c.len)  c.len=k;
        }
        while(c.num[c.len]==0&&c.len>1)  c.len--;
        return c;
    }
    void div(node a,node b){//高精除高精（答案是单精）
        ll l=0,r=2000000000,ans=0;
        while(l<=r){
            ll mid=(l+r)>>1;
            node c=mul(b,mid);
            if(comp(c,a)>=0)  {l=mid+1;  ans=mid;}
            else r=mid-1;
        }
        printf("%d
",ans);
    }
}
void init(){
    scanf("%s",ch1+1);  
    scanf("%s",ch2+1);
    ll n=strlen(ch1+1);
    ll m=strlen(ch2+1);
    down(i,n,1)  A.num[++A.len]=(ll)ch1[i]-'0';
    down(i,m,1)  B.num[++B.len]=(ll)ch2[i]-'0';
}
void output(node c){
    down(i,c.len,1)  printf("%d",c.num[i]);
}
int main(){
    freopen(FILE".in","r",stdin);
    freopen(FILE".out","w",stdout);
    init();
    //node c=High::Mul(A,B);
    //ll p;  scanf("%d",&p);
    //node c=High::mul(A,p);
    //output(c);
    //High::div(A,B);
    return 0;
}