缺省源和模板
缺省源 | 板子
整这个玩意单纯只是怕打比赛时要粘板子发现找不到了。
UPD:2022/11/1 加入 math 模块中，排列组合数的边界判断，以及卢卡斯定理求大数组合数。
UPD:2022/11/6 加入了 modint 类型的 ^,^=,< 等运算。
修改了部分代码。
UPD:2022/11/9 加入 Debug 中，记录程序运行时间的语句。
UPD:2022/11/10 更换了更快的 \(O(1)\) 快速乘，不基于 unsigned long long 的自然溢出，具体参考了这篇 blog。
略微改动 modint 部分，使之支持对题目给定模数取模。
UPD:2022/11/13 更改了整个 Debug 模块，并 加入记录程序使用空间的语句。
缺省源
先是头文件和一堆宏定义，一般都是带着的。
code
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using ull=unsigned long long;
#define lc p<<1
#define rc p<<1|1
#define lb(x) (x&-x)
#define pb push_back
#define ch(i) (i-'a')
#define vi vector<int>
#define F(i) (i).first
#define S(i) (i).second
#define X(i) (i>n?i-n:i)
#define pi pair<int,int>
#define id(x,y) ((x-1)*m+y)
#define cl(x) ((x).clear());
#define si(i) ((int)i.size())
#define kw(x,k) (((x)>>(k))&1)
#define all(x) (x).begin(),(x).end()
#define me(t,x) memset(t,x,sizeof(t))
#define L(i,j,k) for(int (i)=(j);i<=(k);(i)++)
#define R(i,j,k) for(int (i)=(j);i>=(k);(i)--)
#define dout(a,x) cout<<setprecision(x)<<a<<'\n';
#define ll(i,j,k,l) for(int (i)=(j);i<=(k);(i)+=(l))
#define rr(i,j,k,l) for(int (i)=(j);i>=(k);(i)-=(l))
#define FST ios::sync_with_stdio(false);cin.tie(nullptr);
再是用来Debug的一堆宏定义。
提交时把 #define DG 注释掉就行了。
如果是在 Luogu，要把 #pragma GCC optimize(2) 删掉。
就不用挨个调试代码去删了。
在调时也减少了弄混变量数组的情况。
PS:现在暂时不支持直接输出整个数组和容器。将来学会之后或许会加上。
tam 是用于测程序运行时间和空间的。
在 #define DE 的情况下，在程序末尾加上 return tam;，打印运行时间和使用空间。
上交时可以不注释掉(但本地会照常输出)。
测空间要定义两个 char 变量，分别在开头和结尾(反正就是把开的数组夹在中间)。
code
#define DE
#pragma GCC optimize(2)
template<typename ...Args>
void W(string X,Args&&...V){cout<<X<<"]=[";string D=""; (...,(cout<<D<<V,D=","));cout<<"]\n";}
#ifdef DE
#define tam cerr<<1e3*clock()/CLOCKS_PER_SEC<<" ms "<<(&y_y-&x_x)/1024.0/1024.0<<" MB\n",0
#define dg(...) cerr<<__func__<<":"<<__LINE__<<" [",W(#__VA_ARGS__,__VA_ARGS__)
#else
#define dg(...)
#define tam 0
#endif
随机数生成器和序列随机打乱函数，用的是 std::mt19937。
需要 C++11 及以上版本。
分别是生成 \(\left[ l,r \right]\) 范围内的整数和实数。
根据测试，在开启 O2 优化时，1s 大约可以跑 \(5 \cdot 10^7\) 次整数生成或 \(7 \cdot 10^7\) 次实数生成。
时间复杂度近似 \(O(1)\)。
其实是打对拍时用的。
code
mt19937 mrand(chrono::system_clock::now().time_since_epoch().count());
int rnd(int l,int r){
uniform_int_distribution<>dist(l,r);
return dist(mrand);
}double rnd(double l,double r){
uniform_real_distribution<>dist(l,r);
return dist(mrand);
}void dl(vi a){shuffle(all(a),mrand);}
连续读入，输出，没啥用，但还存上了。
code
namespace IO{
template<typename _Tp>void rd(_Tp &x){cin>>x;}
template<typename _Tp,typename ...Args>void rd(_Tp &x,Args &...args){rd(x),rd(args...);}
template<typename _Tp>void wr(_Tp x){cout<<x;}
template<typename _Tp,typename ...Args>void wr(_Tp x,Args ...args){wr(x),wr(args...);}
}using namespace IO;
//rd(x,y,z);
//wr(x,' ',y,'\n');
namespace FT{
void rd(pi &x){IO::rd(F(x),S(x));}
void rd(vi &v,int n){v.resize(n);for(int &p:v) IO::rd(p);}
void wr(pi x,char c){IO::wr(F(x),' ',S(x),c);}
void wr(vi v,char c){for(int p:v) IO::wr(p,c);}
}using namespace FT;
之后是一个 modint 类的封装。
改编自 \(\color{Black}{j} \color{Red}{iangly}\) 的某个提交中部分代码。
就按照普通变量类型定义即可，注意没有取模操作，不然 CE。
相同情况下常数较大。
如果固定模数，就直接对 mod 变量赋值，否则就读入 mod 变量。
后面的 math 模块是时间复杂度 \(O(n)\) 的。
没有直接只是预处理阶乘数组然后直接除是因为这样时间复杂度 \(O(n \log_2 n)\)，且常数较大。
code
int mod;
#define P ((int)mod)
int O(int x){return x<0?(x+=P):x<P?x:(x-=P);}
template<class T>
T ksm(T a,ll b){T s=1;for(;b;b>>=1,a*=a) if(b&1) s*=a;return s;}
struct Z{
int x;Z(int x=0):x(O(x)){}Z(ll x):x(O(x%P)){}
bool operator<(const Z&b)const{return x<b.x;}
bool operator>(const Z&b)const{return x>b.x;}
bool operator<=(const Z&b)const{return x<=b.x;}
bool operator>=(const Z&b)const{return x>=b.x;}
bool operator==(const Z&b)const{return x==b.x;}
bool operator!=(const Z&b)const{return x!=b.x;}
int val()const{return x;}bool operator!(){return !x;}
Z operator-()const{return Z(O(P-x));}
Z inv()const{assert(x!=0);return ksm(*this,P-2);}
Z &operator^=(int b){
Z a=*this,c=1;for(;b;b>>=1,a*=a) if(b&1) c*=a;
return x=c.x,*this;
}Z&operator++(){return x=O(x+1),*this;}
Z&operator--(){return x=O(x-1),*this;}
Z&operator*=(const Z&r){x=(ll)(x)*r.x%P;return*this;}
Z&operator+=(const Z&r){x=O(x+r.x);return*this;}
Z&operator-=(const Z&r){x=O(x-r.x);return*this;}
Z&operator/=(const Z&r){return*this*=r.inv();}
Z&operator+=(const int &r){x=O(x+r);return *this;}
Z&operator-=(const int &r){x=O(x-r);return *this;}
Z&operator*=(const int &r){x=(ll)(x)*r%P;return *this;}
Z&operator/=(const int &r){Z x=r;return *this*=x.inv();}
friend Z operator*(const Z&l,const Z&r){Z s=l;s*=r;return s;}
friend Z operator+(const Z&l,const Z&r){Z s=l;s+=r;return s;}
friend Z operator-(const Z&l,const Z&r){Z s=l;s-=r;return s;}
friend Z operator/(const Z&l,const Z&r){Z s=l;s/=r;return s;}
friend Z operator*(const Z&l,const int&r){Z s=l;s*=r;return s;}
friend Z operator+(const Z&l,const int&r){Z s=l;s+=r;return s;}
friend Z operator-(const Z&l,const int&r){Z s=l;s-=r;return s;}
friend Z operator/(const Z&l,const int&r){Z s=l;s/=r;return s;}
friend Z operator^(Z a,int b){return a^=b;}
friend istream&operator>>(istream&is,Z&a){ll v;is>>v;a=Z(v);return is;}
friend ostream&operator<<(ostream&os,const Z&a){return os<<a.val();}
};namespace math{
Z jc[1000100],ijc[1000100];
void init(int x){
jc[0]=1;L(i,1,x) jc[i]=jc[i-1]*i;
ijc[x]=jc[x].inv();R(i,x,1) ijc[i-1]=ijc[i]*i;
}Z C(int n,int m){return m<0||n<m?0:jc[n]*ijc[n-m]*ijc[m];}
Z A(int n,int m){return m<0||n<m?0:jc[n]*ijc[n-m];}
Z BC(int n,int m){return m?BC(n/P,m/P)*C(n%P,m%P):1;}
}using namespace math;
模板
线性筛质数
用的是 埃氏筛+ std::bitset。
有必要的话把那个 std::vector<int> 加上，存储范围内的质数。
时间复杂度 \(O(n \log_2 \log_2 n)\)，但是实际上跑的比欧拉筛要快(无论欧拉筛是否有 std::bitset 的优化)。
code
bitset<20000000>isp;vi pr;
void es(int n){
isp.set();isp[0]=isp[1]=0;
L(i,2,sqrt(n)) if(isp[i])
ll(j,(i<<1),n,i) isp[j]=0;
// L(i,2,n) if(isp[i]) pr.pb(i);
}
素数检测
用的是 Miller Rabin 质数检测 ，在 long long 范围内应该不会出现错误。
为此还专门加了一个快速幂和快速乘。
时间复杂度 long long :\(O(7 \cdot \log_2 \log_2 \log_2 n)\) int :\(O(3 \cdot \log_2 \log_2 \log_2 n)\)
code
ll qmul(ll a,ll b,ll p) {
ll rt=a*b-((ll)((ld)a/p*b))*p;
return rt>=p?rt-p:rt<0?rt+p:rt;
}ll power(ll a,ll b,ll p){
ll s=1;while(b){
if(b&1) s=qmul(s,a,p);
a=qmul(a,a,p);b>>=1;
}return s;
}bool mr(ll n){
if(n<3||n%2==0) return n==2;
ll u=n-1,t=0;while(!(u&1)) u>>=1,++t;
vi ud;if(n<=2147483647) ud={2,7,61};
else ud={2,325,9375,28178,450775,9780504,1795265022};
for(ll a:ud){
ll v=power(a,u,n);
if(v==1||v==n-1||v==0) continue;
L(j,1,t){
v=qmul(v,v,n);
if(v==n-1&&j!=t){v=1;break;}
if(v==1) return 0;
}if(v^1) return 0;
}return 1;
}
网络流
费用流暂时没有整理，最大流用的是 \(\text{Dinic}\)，也把边封装进去，注意每次跑时的清空。
code
struct flow{
int st,ed,T,a[N];
struct E{int v,w,nt;}e[N<<5];
int fir[N],c=1;
void I(int u,int v,int w){
e[++c]=(E){v,w,fir[u]};fir[u]=c;
e[++c]=(E){u,0,fir[v]};fir[v]=c;
}int cur[N],d[N];
bool bfs(){
L(i,0,ed) d[i]=0,cur[i]=fir[i];
queue<int>q;q.push(st);d[st]=1;
while(!q.empty()){
int u=q.front(),v;q.pop();
E(i,u) if(!d[v=e[i].v]&&e[i].w)
q.push(v),d[v]=d[u]+1;
}return d[ed];
}int dfs(int u,int fl){
if(u==ed) return fl;int s=0,f,v;
for(int i=cur[u];i;i=e[i].nt){
cur[u]=i;
if(e[i].w&&d[v=e[i].v]==d[u]+1){
f=dfs(v,min(e[i].w,fl));
e[i].w-=f;e[i^1].w+=f;
s+=f;fl-=f;if(!fl) break;
}
}if(!s) d[u]=0;return s;
}int dinic(){int s=0;while(bfs()) s+=dfs(st,INF);return s;}
}fl;
最短路
std::priority_queue 优化的 dijkstra，时间复杂度 \(O((n+m) \log_2 m)\)。
code
struct DJ{
vector<pi>g[N];vi dis,vis;
priority_queue<pi>q;
void I(int u,int v,int w){g[u].pb({v,w});}
void init(int x,int s){
dis.resize(s+1);fill(all(dis),INF);
vis.resize(s+1);fill(all(vis),0);
dis[x]=0;q.push({0,x});
}void dij(){
while(!q.empty()){
int u=S(q.top());q.pop();
if(vis[u]) continue;vis[u]=1;
for(auto x:g[u])
if(dis[F(x)]>dis[u]+S(x)){
dis[F(x)]=dis[u]+S(x);
if(!vis[F(x)]) q.push({-dis[F(x)],F(x)});
}
}
}
};
LCA
比较冷门的 dfs 序求 LCA，预处理 \(O(n \log_2 n)\)，查询 \(O(1)\)，基于 dfs 序和 ST 表。
相比于传统的欧拉序 LCA 更好写，更短，没有双倍的常数和空间。
code
int n,m,u,v,rt;vi g[N];
struct dl{
int dn,dfn[N],d[N],lg[N],st[19][N];
int get(int x,int y){return d[x]<d[y]?x:y;}
void dfs(int u,int f){
st[0][dfn[u]=++dn]=f;d[u]=d[f]+1;
for(int v:g[u]) if(v^f) dfs(v,u);
}int lca(int u,int v){
if(u==v) return u;if((u=dfn[u])>(v=dfn[v])) swap(u,v);
int d=lg[v-u++];return get(st[d][u],st[d][v-(1<<d)+1]);
}void init(){
L(i,1,lg[n]) L(j,1,(n+1-(1<<i)))
st[i][j]=get(st[i-1][j],st[i-1][j+(1<<i-1)]);
}
};
BIT
就树状数组，加一个权值树状数组的 kth 函数。
code
struct BIT{
int n,c[N];void add(int x,int k){for(;x<=n;x+=lb(x)) c[x]+=k;}
int ask(int x){int s=0;for(;x;x-=lb(x)) s+=c[x];return s;}
int kth(int k){
int r=0,t=0;
for(int i=lg/*log2(值域)*/,x,y;~i;i--){
if((x=r+(1<<i))>n) continue;
if((y=t+c[x])<k) r=x,t=y;
}return a[r];//a 是离散化前的数组
}
};
