前言
再过两天就\(NOIP2018\)了。
于是，我决定不做其他题目，开始一心一意刷板子了。
这篇博客记录的就是我的刷板子计划。
【洛谷3383】【模板】线性筛素数
这种普及-的题目我还写挂了两次（感觉自己废掉了）。
好吧，第一次写挂是因为数组开小了，第二次写挂是因为没有特判\(1\)不是质数... ...
class Class_LineSiever
{
private:
#define PrimeSize 1000000
bool IsNot[PrimeSize+5];
public:
int Prime_cnt,Prime[PrimeSize+5];
inline void Sieve(int Size)
{
register int i,j;
for(IsNot[1]=true,i=2;i<=Size;++i)
{
if(!IsNot[i]) Prime[++Prime_cnt]=i;
for(j=1;j<=Prime_cnt&&1LL*i*Prime[j]<=Size;++j) if(IsNot[i*Prime[j]]=true,!(i%Prime[j])) break;
}
}
inline bool IsPrime(int x) {return !IsNot[x];}
};【洛谷3370】【模板】字符串哈希
这真的是比较基础的题目。（看以前的提交记录发现我之前是用\(map\)过的... ...）
class Class_StringHasher
{
private:
#define ull unsigned long long
struct Hash
{
ull fir,sec;
Hash(ull x=0,ull y=0):fir(x),sec(y){}
inline friend Hash operator + (Hash x,Hash y) {return Hash(x.fir+y.fir,x.sec+y.sec);}
inline friend Hash operator - (Hash x,Hash y) {return Hash(x.fir-y.fir,x.sec-y.sec);}
inline friend Hash operator * (Hash x,Hash y) {return Hash(x.fir*y.fir,x.sec*y.sec);}
inline friend bool operator < (Hash x,Hash y) {return x.fir^y.fir?x.fir vis;
inline Hash GetHash(string x)
{
register int i,len=x.length();register Hash res=0;
for(i=0;i 【洛谷3366】【模板】最小生成树
分别使用\(Prim\)和\(Kruskal\)各写了一遍。
发现自己对\(Prim\)已经有一些陌生了，直至看到代码才想起来它可以用堆优化... ...（感觉自己好菜）
class Class_PrimSpanner
{
private:
int dis[N+5],vis[N+5];typedef pair Status;priority_queue,greater > q;
public:
inline int GetAns()
{
register int i,ans=0;register Status k;
for(i=2;i<=n;++i) dis[i]=INF;q.push(make_pair(dis[1]=0,1));
while(!q.empty())
{
while(!q.empty()&&vis[q.top().second]) q.pop();
if(q.empty()) break;
for(k=q.top(),q.pop(),ans+=k.first,vis[k.second]=1,i=lnk[k.second];i;i=e[i].nxt)
if(!vis[e[i].to]&&e[i].val class Class_KruskalSpanner
{
private:
class Class_UnionFindSet
{
private:
int fa[N+5],level[N+5];
inline int getfa(int x) {return fa[x]^x?fa[x]=getfa(fa[x]):x;}
public:
inline void Init() {for(register int i=1;i<=n;++i) fa[i]=i;}
inline bool Identify(int x,int y) {return !(getfa(x)^getfa(y));}
inline void Union(int x,int y) {((x=getfa(x))^(y=getfa(y)))&&(level[x]【洛谷3369】【模板】普通平衡树
这是我比较担心的一块。
分别用替罪羊树、\(Treap\)和\(Splay\)三种平衡树各码了一遍板子。
码板子的过程中还是发现了一些细节问题，所以有点怕即使\(NOIP\)考了平衡树我都不一定敢写。
class Class_ScapegoatTree
{
private:
#define Alpha 0.75
#define NewNode() (VoidSize?Void[VoidSize--]:++tot)
#define Init(x) (node[x].Exist=node[x].Size=node[x].Fac=1,node[x].Son[0]=node[x].Son[1]=0)
#define Balance(x) (Alpha*node[x].Fac>1.0*max(node[node[x].Son[0]].Fac,node[node[x].Son[1]].Fac))
#define PushUp(x) (void)(node[x].Size=node[node[x].Son[0]].Size+node[node[x].Son[1]].Size+1,node[x].Fac=node[node[x].Son[0]].Fac+node[node[x].Son[1]].Fac+node[x].Exist)
#define ReBuild(x) (void)(cnt=0,Traversal(x),cnt?(SetUp(x,1,cnt),0):x=0)
int rt,tot,cnt,cur[N+5],VoidSize,Void[N+5];
struct Tree
{
int Val,Exist,Size,Fac,Son[2];
Tree(int x=0):Val(x){Exist=Size=Fac=Son[0]=Son[1]=0;}
}node[N+5];
inline void Traversal(int x) {x&&(Traversal(node[x].Son[0]),(node[x].Exist?cur[++cnt]=x:Void[++VoidSize]=x),Traversal(node[x].Son[1]),0);}
inline void SetUp(int &x,int l,int r) {register int mid=l+r>>1;Init(x=cur[mid]),lmid&&(SetUp(node[x].Son[1],mid+1,r),0),PushUp(x);}
inline void ins(int &x,int val) {if(!x) return (void)(node[x=NewNode()]=Tree(val),Init(x));++node[x].Size,++node[x].Fac,ins(node[x].Son[node[x].Val1.0*node[rt].Fac&&(ReBuild(rt),0);}
inline int get_val(int rk) {register int x=rt,t;while(x) if((t=node[node[x].Son[0]].Fac+node[x].Exist)==rk&&node[x].Exist) return node[x].Val;else t class Class_Treap
{
private:
#define ull unsigned long long
#define NewNode() (VoidSize?Void[VoidSize--]:++tot)
#define Init(x) (node[x].Size=node[x].Cnt=1,node[x].Data=1ull*rand()*rand()*rand()*rand()*rand())
#define PushUp(x) (node[x].Size=node[node[x].Son[0]].Size+node[node[x].Son[1]].Size+node[x].Cnt)
int rt,tot,VoidSize,Void[N+5];
struct Tree
{
int Val,Size,Cnt,Son[2];ull Data;
Tree(int x=0):Val(x){Size=Cnt=Data=Son[0]=Son[1]=0;}
}node[N+5];
inline void Rotate(int &x,int d) {register int k=node[x].Son[d^1];node[x].Son[d^1]=node[k].Son[d],node[k].Son[d]=x,PushUp(x),PushUp(k),x=k;}
inline void ins(int &x,int val)
{
if(!x) return (void)(node[x=NewNode()]=Tree(val),Init(x));
if(++node[x].Size,!(node[x].Val^val)) return (void)(++node[x].Cnt);
register int d=node[x].Val1) return (void)(--node[x].Cnt,--node[x].Size);
if(!node[x].Son[0]||!node[x].Son[1]) return (void)(x=node[x].Son[0]+node[x].Son[1]);
register int d=node[node[x].Son[0]].Data=rk) x=node[x].Son[0];
else if(rk-=node[node[x].Son[0]].Size,node[x].Cnt>=rk) return node[x].Val;
else rk-=node[x].Cnt,x=node[x].Son[1];
}
}
inline int get_pre(int val)
{
register int x=rt,pre=-INF;
while(x) node[x].Valval?(nxt=node[x].Val,x=node[x].Son[0]):x=node[x].Son[1];
return nxt;
}
}; class Class_Splay
{
private:
#define NewNode() (VoidSize?Void[VoidSize--]:++tot)
#define Init(x) (node[x].Size=node[x].Cnt=1,node[x].Son[0]=node[x].Son[1]=0)
#define Which(x) (node[node[x].Father].Son[1]==x)
#define Connect(x,y,d) (node[node[x].Father=y].Son[d]=x)
#define PushUp(x) (node[x].Size=node[node[x].Son[0]].Size+node[node[x].Son[1]].Size+node[x].Cnt)
int rt,tot,VoidSize,Void[N+5];
struct Tree
{
int Val,Size,Cnt,Father,Son[2];
Tree(int x=0,int y=0):Val(x),Father(y){Size=Cnt=Son[0]=Son[1]=0;}
}node[N+5];
inline void Rotate(int x,int &k)
{
register int fa=node[x].Father,pa=node[fa].Father,d=Which(x);
(fa^k?node[pa].Son[Which(fa)]=x:k=x),node[x].Father=pa,Connect(node[x].Son[d^1],fa,d),Connect(fa,x,d^1),PushUp(fa),PushUp(x);
}
inline void Splay(int x,int &k)
{
register int fa=node[x].Father;
while(x^k) fa^k&&(Rotate(Which(x)^Which(fa)?x:fa,k),0),Rotate(x,k),fa=node[x].Father;
PushUp(x);
}
inline void ins(int &x,int val,int lst)
{
if(!x) return (void)(node[x=NewNode()]=Tree(val,lst),Init(x),Splay(x,rt));
if(++node[x].Size,!(node[x].Val^val)) return (void)(++node[x].Cnt,Splay(x,rt));
ins(node[x].Son[node[x].Val=rk) x=node[x].Son[0];
else if(rk-=node[node[x].Son[0]].Size,node[x].Cnt>=rk) return Splay(x,rt),node[x].Val;
else rk-=node[x].Cnt,x=node[x].Son[1];
}
}
inline void Delete(int val)
{
if(get_rank(val),--node[rt].Cnt) return;
if(!node[rt].Son[0]||!node[rt].Son[1]) return (void)(node[rt=node[rt].Son[0]+node[rt].Son[1]].Father=0);
register int k=node[rt].Son[0];
while(node[k].Son[1]) k=node[k].Son[1];
Connect(node[rt].Son[1],k,1),node[rt=node[rt].Son[0]].Father=0;
}
inline int get_pre(int val)
{
register int x=rt,pre=-INF;
while(x) node[x].Valval?(nxt=node[x].Val,x=node[x].Son[0]):x=node[x].Son[1];
return nxt;
}
}; 【洛谷3391】【模板】文艺平衡树
\(Splay\)维护数列的最经典例题（也是最水例题）。
这题也花了挺多时间在调试上，结果果真发现犯了一个智障的错误... ...
class Class_Splay
{
private:
#define Which(x) (node[node[x].Father].Son[1]==x)
#define PushUp(x) (node[x].Size=node[node[x].Son[0]].Size+node[node[x].Son[1]].Size+1)
#define PushDown(x) (node[x].Rev&&(swap(node[x].Son[0],node[x].Son[1]),node[node[x].Son[0]].Rev^=1,node[node[x].Son[1]].Rev^=1,node[x].Rev=0))
#define Connect(x,y,d) (node[node[x].Father=y].Son[d]=x)
#define Split(x,y) (Splay(get_pos(x),rt),Splay(get_pos((y)+2),node[rt].Son[1]),node[node[rt].Son[1]].Son[0])
int rt,tot,data[N+5];
struct node
{
int Val,Size,Father,Rev,Son[2];
}node[N+5];
inline void bld(int l,int r,int &rt)
{
register int mid=l+r>>1;rt=++tot,
lmid&&(bld(mid+1,r,node[rt].Son[1]),node[node[rt].Son[1]].Father=rt),
node[rt].Val=data[mid],PushUp(rt);
}
inline void Rotate(int x,int &k)
{
register int fa=node[x].Father,pa=node[fa].Father,d=Which(x);
(fa^k?node[pa].Son[Which(fa)]=x:k=x),node[x].Father=pa,Connect(node[x].Son[d^1],fa,d),Connect(fa,x,d^1),PushUp(fa),PushUp(x);
}
inline void Splay(int x,int &k)
{
register int fa=node[x].Father;
while(x^k) fa^k&&(Rotate(Which(x)^Which(fa)?x:fa,k),0),Rotate(x,k),fa=node[x].Father;
PushUp(x);
}
inline int get_pos(int rk)
{
register int x=rt;
while(x)
{
if(PushDown(x),node[node[x].Son[0]].Size>=rk) x=node[x].Son[0];
else if(rk-=node[node[x].Son[0]].Size,!(rk^1)) return x;
else --rk,x=node[x].Son[1];
}
}
public:
inline void Build(int n) {for(register int i=2;i<=n+1;++i) data[i]=i-1;data[1]=-INF,data[n+2]=INF,bld(1,n+2,rt);}
inline void Rever(int l,int r) {register int k=Split(l,r);node[k].Rev^=1;}
inline int get_num(int x) {return node[get_pos(x+1)].Val;}
}; 【洛谷4779】【模板】单源最短路径（标准版）
第一次知道\(Dijkstra\)可以用线段树优化。
\(WA\)了好几发，原因是没有看到题目中的边是有向边，感觉自己像个智障。
我没有写\(SPFA\)板子，毕竟它已经死了。
class Class_Dijkstra
{
private:
class Class_SegmentTree
{
private:
#define Left l,mid,rt<<1
#define Right mid+1,r,rt<<1|1
#define PushUp(x) (node[x]=min(node[x<<1],node[x<<1|1]))
pair node[N<<2];
inline void upt(int l,int r,int rt,int pos,int val) {if(l==r) return (void)(node[rt]=make_pair(val,l));register int mid=l+r>>1;(pos<=mid?upt(Left,pos,val):upt(Right,pos,val)),PushUp(rt);}
public:
inline void Build(int l=1,int r=n,int rt=1) {if(l==r) return (void)(node[rt]=make_pair(INF,l));register int mid=l+r>>1;Build(Left),Build(Right),PushUp(rt);}
inline void Update(int pos,int val) {upt(1,n,1,pos,val);}
inline pair Query() {return node[1];}
}S;
public:
int dis[N+5];
inline void Solve(int s)
{
register int i,Time;register pair k;
for(S.Build(),i=1;i<=n;++i) dis[i]=INF;
for(S.Update(s,dis[s]=0),Time=1;Time<=n;++Time)
{
for(k=S.Query(),S.Update(k.second,INF),i=lnk[k.second];i;i=e[i].nxt)
dis[e[i].to]>k.first+e[i].val&&(S.Update(e[i].to,dis[e[i].to]=k.first+e[i].val),0);
}
}
}; 【洛谷3374】【模板】树状数组1&&【洛谷3368】【模板】树状数组2
对于树状数组我真的是完全不懂啊。
今天好好学了一下，貌似有点理解了它的大致思想。
我相信考到树状数组题我肯定会去写线段树，即使它常数比较大。
class Class_TreeArray
{
private:
#define lowbit(x) ((x)&-(x))
int data[N+5];
inline int qry(int x) {register int res=0;while(x) res+=data[x],x-=lowbit(x);return res;}
public:
inline void Add(int x,int val) {while(x<=n) data[x]+=val,x+=lowbit(x);}
inline int Query(int l,int r) {return qry(r)-qry(l-1);}
};class Class_TreeArray
{
private:
#define lowbit(x) ((x)&-(x))
int val[N+5],data[N+5];
public:
inline int Init(int len,int *num) {for(register int i=1;i<=len;++i) val[i]=num[i];}
inline void Add(int x,int val) {while(x<=n) data[x]+=val,x+=lowbit(x);}
inline int Query(int x) {register int res=val[x];while(x) res+=data[x],x-=lowbit(x);return res;}
};【洛谷3884】【模板】可持久化线段树1（主席树）
最近写了挺多主席树题，因此还算是比较熟练的吧。
但样例依然调了很久。
最后发现问题竟错在我最相信不会错的离散化上... ...
class Class_ChairmanTree
{
private:
int tot,Root[N+5];
struct Tree
{
int Size,Son[2];
}node[N*LogN+5];
class Class_Discretization
{
private:
int data[N+5];
public:
int cnt;
inline void Init(int n,int *num) {for(register int i=1;i<=n;++i) data[i]=num[i];sort(data+1,data+n+1),cnt=unique(data+1,data+n+1)-data-1;}
inline int get_val(int x) {register int l=1,r=cnt,mid;while(l<=r) data[mid=l+r>>1]>1;
val<=mid?ins(l,mid,node[rt].Son[0],node[lst].Son[0],val):ins(mid+1,r,node[rt].Son[1],node[lst].Son[1],val);
}
inline int qry(int l,int r,int rt1,int rt2,int k)
{
if(!(l^r)) return l;
register int mid=l+r>>1,t=node[node[rt2].Son[0]].Size-node[node[rt1].Son[0]].Size;
return t>=k?qry(l,mid,node[rt1].Son[0],node[rt2].Son[0],k):qry(mid+1,r,node[rt1].Son[1],node[rt2].Son[1],k-t);
}
public:
inline void Init(int len,int *num) {D.Init(len,num);for(register int i=1;i<=n;++i) ins(1,D.cnt,Root[i],Root[i-1],D.get_val(num[i]));}
inline int Query(int l,int r,int k) {return D.get_fac(qry(1,D.cnt,Root[l-1],Root[r],k));}
}; 【洛谷3865】【模板】ST表
练了一下\(RMQ\)，毕竟这个算法我经常写炸。
class Class_RMQ
{
private:
int Log[N+5],Max[N+5][LogN+5];
public:
inline void Init(int *data)
{
register int i,j;
for(i=2;i<=n;++i) Log[i]=Log[i>>1]+1;
for(i=1;i<=n;++i) Max[i][0]=data[i];
for(j=1;(1<【洛谷3390】【模板】矩阵快速幂
对于矩阵乘法及矩阵快速幂我之前学过，但现在已经忘得差不多了... ...
所以相当于又重学了一遍吧。
class Class_Matrix
{
private:
int n,m;
public:
int num[N+5][N+5];
Class_Matrix(int x=0,int y=0):n(x),m(y){memset(num,0,sizeof(num));}
inline friend Class_Matrix operator * (Class_Matrix x,Class_Matrix y)
{
register int i,j,k;register Class_Matrix res(x.n,y.m);
for(i=1;i<=x.n;++i) for(j=1;j<=y.m;++j) for(k=1;k<=x.m;++k) (res.num[i][j]+=1LL*x.num[i][k]*y.num[k][j]%XRY)%=XRY;
return res;
}
inline friend Class_Matrix operator ^ (Class_Matrix x,LL y)
{
register Class_Matrix res(x.n,x.n);
for(register int i=1;i<=x.n;++i) res.num[i][i]=1;
while(y) (y&1)&&(res=res*x,0),x=x*x,y>>=1;
return res;
}
};【洛谷3375】【模板】KMP字符串匹配
对\(KMP\)这个东西我真的是一脸懵逼。
勉勉强强莫名其妙过了样例，一交结果只有\(80\)分。
仔细一检查+调试，总算发现自己少写了一个\(=\)。
好不容易过了。
class Class_KMP
{
private:
int Next[N+5];
inline void GetNext(string s1,string s2)
{
register int i,j=Next[0]=-1,len1=s1.length(),len2=s2.length();
for(i=1;i<=len2;++i)
{
while(~j&&s2[i-1]^s2[j]) j=Next[j];
Next[i]=++j;
}
}
public:
inline void Solve(string s1,string s2)
{
int i,j=-1,len1=s1.length(),len2=s2.length();
for(GetNext(s1,s2),i=0;i<=len1;++i)
{
while(~j&&s1[i-1]^s2[j]) j=Next[j];
if(++j==len2) F.write(i-len2+1),j=Next[j],F.writec('\n');
}
for(i=1;i<=len2;++i) F.write(Next[i]),F.writec(' ');
}
};【洛谷3811】【模板】线性求逆元
线性求逆元我现在是真的不会了。
重新看了一下以前写过的博客：浅谈乘法逆元的三种解法，才弄懂了逆元应该怎么求。
class Class_InvIniter
{
public:
int Inv[N+5];Class_InvIniter() {Inv[1]=1;}
inline void Init(int x,int XRY) {for(register int i=2;i<=x;++i) Inv[i]=(-1LL*(XRY/i)*Inv[XRY%i]%XRY+XRY)%XRY;}
}InvIniter;【洛谷3372】【模板】线段树1&&【洛谷3373】【模板】线段树2
线段树应该还是比较简单的一种数据结构吧。
但是，一题因为没开\(long\ long\)，一题因为没取模，都尴尬地\(WA\)了好几发。
class Class_SegmentTree
{
private:
#define Left l,mid,rt<<1
#define Right mid+1,r,rt<<1|1
#define PushUp(x) (node[x]=node[x<<1]+node[x<<1|1])
#define PushDown(x) (node[x].flag&&(node[x<<1].F5(node[x].flag,mid-l+1),node[x<<1|1].F5(node[x].flag,r-mid),node[x].flag=0))
int n;LL data[N+5];
struct Tree
{
LL Sum,flag;
Tree(LL x=0,LL f=0):Sum(x),flag(f){}
inline friend Tree operator + (Tree x,Tree y) {return Tree(x.Sum+y.Sum);}
inline void F5(LL x,int len) {Sum+=x*len,flag+=x;}
}node[N<<2];
inline void bld(int l,int r,int rt)
{
if(!(l^r)) return (void)(node[rt]=Tree(data[l]));
register int mid=l+r>>1;
bld(Left),bld(Right),PushUp(rt);
}
inline void upt(int l,int r,int rt,int ul,int ur,LL val)
{
if(ul<=l&&r<=ur) return (void)(node[rt].F5(val,r-l+1));
register int mid=l+r>>1;
PushDown(rt),ul<=mid&&(upt(Left,ul,ur,val),0),ur>mid&&(upt(Right,ul,ur,val),0),PushUp(rt);
}
inline LL qry(int l,int r,int rt,int ql,int qr)
{
if(ql<=l&&r<=qr) return node[rt].Sum;
register int mid=l+r>>1;register LL res=0;
return PushDown(rt),ql<=mid&&(res+=qry(Left,ql,qr)),qr>mid&&(res+=qry(Right,ql,qr)),res;
}
public:
inline void Build(int len,LL *num) {n=len;for(register int i=1;i<=n;++i) data[i]=num[i];bld(1,n,1);}
inline void Update(int l,int r,LL val) {upt(1,n,1,l,r,val);}
inline LL Query(int l,int r) {return qry(1,n,1,l,r);}
};class Class_SegmentTree
{
private:
#define Left l,mid,rt<<1
#define Right mid+1,r,rt<<1|1
#define PushUp(x) (node[x]=node[x<<1]+node[x<<1|1])
#define PushDown(x) ((node[x].flag1^1||node[x].flag2)&&(node[x<<1].F5(node[x].flag1,node[x].flag2,mid-l+1),node[x<<1|1].F5(node[x].flag1,node[x].flag2,r-mid),node[x].flag1=1,node[x].flag2=0))
int n;int data[N+5];
struct Tree
{
int Sum,flag1,flag2;
Tree(int x=0,int f1=1,int f2=0):Sum(x),flag1(f1),flag2(f2){}
inline friend Tree operator + (Tree x,Tree y) {return Tree(GetSum(x.Sum,y.Sum));}
inline void F5(int x,int y,int len) {Sum=GetSum(1LL*Sum*x%XRY,1LL*y*len%XRY),flag1=1LL*flag1*x%XRY,flag2=GetSum(1LL*flag2*x%XRY,y);}
}node[N<<2];
inline void bld(int l,int r,int rt)
{
if(!(l^r)) return (void)(node[rt]=Tree(data[l]));
register int mid=l+r>>1;
bld(Left),bld(Right),PushUp(rt);
}
inline void mul(int l,int r,int rt,int ul,int ur,int val)
{
if(ul<=l&&r<=ur) return (void)(node[rt].F5(val,0,r-l+1));
register int mid=l+r>>1;
PushDown(rt),ul<=mid&&(mul(Left,ul,ur,val),0),ur>mid&&(mul(Right,ul,ur,val),0),PushUp(rt);
}
inline void add(int l,int r,int rt,int ul,int ur,int val)
{
if(ul<=l&&r<=ur) return (void)(node[rt].F5(1,val,r-l+1));
register int mid=l+r>>1;
PushDown(rt),ul<=mid&&(add(Left,ul,ur,val),0),ur>mid&&(add(Right,ul,ur,val),0),PushUp(rt);
}
inline int qry(int l,int r,int rt,int ql,int qr)
{
if(ql<=l&&r<=qr) return node[rt].Sum;
register int mid=l+r>>1,res=0;
return PushDown(rt),ql<=mid&&Inc(res,qry(Left,ql,qr)),qr>mid&&Inc(res,qry(Right,ql,qr)),res;
}
public:
inline void Build(int len,int *num) {n=len;for(register int i=1;i<=n;++i) data[i]=num[i];bld(1,n,1);}
inline void Mul(int l,int r,int val) {mul(1,n,1,l,r,val);}
inline void Add(int l,int r,int val) {add(1,n,1,l,r,val);}
inline int Query(int l,int r) {return qry(1,n,1,l,r);}
};【洛谷1939】【模板】矩阵加速（数列）
这题其实就是前面矩阵快速幂的应用。
因此代码省略了。
【洛谷3379】【模板】最近公共祖先（LCA）
\(LCA\)可谓是一个比较常用的技巧吧。
常见的\(LCA\)据说有\(4\)中：倍增\(LCA\)、树剖\(LCA\)、\(Tarjan\ LCA\)和\(RMQ\ LCA\)。
但我只会第一种。
class Class_LCA
{
private:
int Depth[N+5],fa[N+5][LogN+5];
public:
inline void Init(int x=0)
{
register int i;
for(i=1;i<=LogN;++i) fa[x][i]=fa[fa[x][i-1]][i-1];
for(i=lnk[x];i;i=e[i].nxt) e[i].to^fa[x][0]&&(Depth[e[i].to]=Depth[fa[e[i].to][0]=x]+1,Init(e[i].to),0);
}
inline int Query(int x,int y)
{
register int i;
if(Depth[x]【洛谷3807】【模板】卢卡斯定理
这题数据真的很水，貌似暴力也可以过... ...
class Class_Lucas
{
private:
#define GetC(x,y) (x>=1;
return res;
}
public:
inline void Init()
{
register int i;
for(i=1,Fac[0]=1;i 【洛谷2197】【模板】nim游戏
这种博弈论题还是比较简单的。
只要求出异或和，异或和为\(0\)输出\(No\)，不为\(0\)输出\(Yes\)。
代码略。
【洛谷1439】【模板】最长公共子序列
\(O(n^2)\)的最长公共子序列是很好求的。
但观察数据，显然\(O(n^2)\)会被卡。
考虑两个序列分别是\(1\sim n\)的排列，就不难想到将其转化成最长上升子序列来实现\(O(nlogn)\)求解。
代码略。
【洛谷3386】【模板】二分图匹配
自然，这道题可以用网络流来做。
但我写的是匈牙利算法。
class Class_Hungarian
{
private:
int s[N+5],vis[N+5];
public:
inline bool Match(int x,int Time)
{
for(register int i=lnk[x];i;i=e[i].nxt)
{
if(!(vis[e[i].to]^Time)) continue;
if(vis[e[i].to]=Time,!s[e[i].to]||Match(s[e[i].to],Time)) return s[e[i].to]=x,true;
}
return false;
}
};【洛谷2613】【模板】有理数取余
这应该是比较裸的乘法逆元。
唯一要注意的是，为了避免高精度，我们可以一边读入一边取模。
代码略。
【洛谷3805】【模板】manacher算法
\(Manacher\)算法是比较常见的回文算法。
我个人认为它还是比较重要的吧。
class Class_Manacher
{
private:
int len,p[(N<<1)+5];char ns[(N<<1)+5];
public:
inline void Init(char *s)
{
register int i,l=strlen(s);
for(ns[i=0]='!',ns[len=1]='%';iMax&&(Max=i+p[id=i]),Gmax(ans,p[i]-1);
}
return ans;
}
}; 【洛谷3389】【模板】高斯消元法
高斯消元真的是一个比较有趣的数学算法。
判断变量是否为\(0\)时写了一个\(v
class Class_Gauss
{
private:
#define eps 1e-15
#define Exit() (puts("No Solution"),exit(0),0)
double v[N+5][N+5],res[N+5];
inline void swap(double x,double y) {double t=x;x=y,y=t;}
inline void FindLine(int x)
{
register int i,p=x;
while(fabs(v[p][x])n&&Exit(),i=1;i<=n;++i) swap(v[x][i],v[p][i]);
}
public:
inline void GetData(int x,int y,double t) {v[x][y]=t;}
inline void GetRes(int x,int t) {res[x]=t;}
inline void Solve()
{
register int i,j,k;register double delta;
for(i=1;i<=n;++i) for(FindLine(i),j=i+1;j<=n;++j) for(res[j]+=res[i]*(delta=-v[j][i]/v[i][i]),k=i;k<=n;++k) v[j][k]+=v[i][k]*delta;
for(i=n;i;--i) for(fabs(v[i][i]) 【洛谷3388】【模板】割点（割顶）
好吧，对于割点与桥，我真的是忘得一干二净。
重新去学习了一遍... ...
class Class_CutPointFinder
{
private:
int d,low[N+5];
public:
int dfn[N+5],IsCut[N+5];
inline void Solve(int x,int lst=0)
{
register int i,tot=0;
for(dfn[x]=low[x]=++d,i=lnk[x];i;i=e[i].nxt)
{
if(!(e[i].to^lst)) continue;
if(!dfn[e[i].to])
{
Solve(e[i].to,x),Gmin(low[x],low[e[i].to]),++tot;
if(lst&&low[e[i].to]>=dfn[x]) IsCut[x]=1;
}
else Gmin(low[x],dfn[e[i].to]);
}
if(!lst&&tot>1) IsCut[x]=1;
}
};【洛谷3385】【模板】负环
这题看起来只是一道简单的板子题，以为很快就能过的。
没想到的是，先是看错了题目，好不容易才调过样例，一交\(WA\)了，手玩感觉没问题，才发现题目中说大于等于\(0\)的边是双向边... ...
接下来更是尴尬，第\(9\)个点一直在\(WA\)与\(TLE\)中徘徊。
听说用\(STL\)队列会超时，因此我一直是手写循环队列的。没想到把手写队列改成了\(STL\)队列之后，原来\(TLE\)的点竟\(50ms\)出答案了！
真香。
class Class_NegativeRingFinder
{
private:
int dis[N+5],Inqueue[N+5];queue q;
public:
int vis[N+5];
inline bool Exist(int s)
{
register int i,k;
for(i=1;i<=n;++i) dis[i]=INF,Inqueue[i]=vis[i]=0;
while(!q.empty()) q.pop();q.push(1);
dis[s]=0,Inqueue[s]=1;
while(!q.empty())
{
for(Inqueue[k=q.front()]=0,q.pop(),i=lnk[k];i;i=e[i].nxt)
{
if(dis[e[i].to]>dis[k]+e[i].val)
{
if((vis[e[i].to]=vis[k]+1)>=n) return true;
if(dis[e[i].to]=dis[k]+e[i].val,!Inqueue[e[i].to]) Inqueue[e[i].to]=1,q.push(e[i].to);
}
else if(dis[e[i].to]==dis[k]+e[i].val&&e[i].val>0&&(vis[e[i].to]+=vis[k])>=n) return true;
}
}
return false;
}
}; 【洛谷3387】【模板】缩点
这题可不是一道单纯的缩点题，还要在\(DAG\)上跑\(DP\)。
实际上还是蛮简单的。
突然发现我最近用了大约\(1\)个月的一个\(\#define\)出锅了，莫名慌了。
或许我在\(NOIP\)期间是不会用\(\#define\)了，即使它比函数的常数要小得多。
代码我还是单纯贴一下缩点的代码吧：
class Class_Tarjan
{
private:
int d,Top,low[N+5],InStack[N+5],Stack[N+5];
public:
int cnt,dfn[N+5],col[N+5],sum[N+5];
inline void Solve(int x,int lst=0)
{
register int i;
for(dfn[x]=low[x]=++d,InStack[Stack[++Top]=x]=1,i=lnk[x];i;i=e[i].nxt)
{
if(!dfn[e[i].to]) Solve(e[i].to,x),Gmin(low[x],low[e[i].to]);
else if(InStack[e[i].to]) Gmin(low[x],dfn[e[i].to]);
}
if(low[x]^dfn[x]) return;
sum[col[x]=++cnt]=val[x],InStack[x]=0;
while(Stack[Top]^x) sum[col[Stack[Top]]=cnt]+=val[Stack[Top]],InStack[Stack[Top--]]=0;
--Top;
}
};【洛谷3376】【模板】网络最大流
这应该不是提高组范围内的吧。
依然智障地将一个\(t\)写成了\(T\)，又是一波调试。
class Class_Dinic
{
private:
int FlowTotal,q[N+5],cur[N+5],Depth[N+5];
inline bool BFS()
{
register int i,k,H=1,T=1;
for(i=1;i<=n;++i) Depth[i]=0;Depth[q[1]=s]=1;
while(H<=T&&!Depth[t]) for(i=lnk[k=q[H++]];i;i=e[i].nxt) !Depth[e[i].to]&&e[i].Cap>e[i].Flow&&(Depth[q[++T]=e[i].to]=Depth[k]+1);
return Depth[t];
}
inline int DFS(int x,int f=INF)
{
if(!(x^t)||!f) return f;
register int i,res=0,NowFlow;
for(i=lnk[x];i;i=e[i].nxt)
{
if(Depth[e[i].to]^(Depth[x]+1)||e[i].Cap<=e[i].Flow||!(NowFlow=DFS(e[i].to,min(f,e[i].Cap-e[i].Flow)))) continue;
if(e[i].Flow+=NowFlow,e[((i-1)^1)+1].Flow-=NowFlow,res+=NowFlow,!(f-=NowFlow)) return res;
}
return res;
}
public:
inline void Solve()
{
register int i;
while(BFS())
{
for(i=1;i<=n;++i) cur[i]=lnk[i];
FlowTotal+=DFS(s);
}
F.write(FlowTotal);
}
};【洛谷3808】【模板】AC自动机（简单版）&&【洛谷3796】【模板】AC自动机（加强版）
\(AC\)自动机是一个比较神奇的字符串算法，当时学的时候也花了挺多时间去理解，今天又用了一个多小时才做掉了简单版的板子题。
错误原因很尴尬，题目中文本串是在最后一行读入的，结果我以为是在第一行读入的... ...结果莫名\(RE\)调试到心态爆炸... ...
加强版的板子我炸得更惨，我现在才知道连续开多个字符数组要稍微开大一点，不然会把你一次性全部输出... ...
代码就贴一下简单版的吧：
class Class_AC_Automation
{
private:
#define Size 1000000
int rt,tot,q[Size+5];
struct Trie
{
int Sum,Next,Son[27];
}node[Size+5];
public:
Class_AC_Automation() {rt=tot=1;}
inline void Insert(char *s,int len)
{
register int i,x=rt,nxt;
for(i=0;i后记
虽然还有很多板子没做，但\(NOIP2018\)还是很快到来了，而直至\(NOIP\)结束，我也没能成功把板子刷完。
关于\(NOIP2018\)，可以看这篇博客：NOIP2018学军中学游记。
不得不承认，我刷的这些板子，在此次比赛中没有发挥任何作用。
但是我想，复习算法总是有一定意义的吧。（自我安慰）