模板合集
矩阵乘法以及求逆（实数）
struct matrix{
int n,m;
double a[N][N];
matrix(int nn,int mm):n(nn),m(mm){
memset(a,0,sizeof(a));
}
matrix operator *(const matrix &x) const{
matrix b(n,x.m);
for(int k=1;k<=n;++k)
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
b.a[i][j]+=a[i][k]*x.a[k][j];
return b;
}
matrix inverse(const matrix &x){
assert(x.n==x.m);
int n=x.n;
double p[N][2*N];
memset(p,0,sizeof(p));
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j){
p[i][j]=x.a[i][j];
p[i][j+n]=(i==j);
}
for(int i=1;i<=n;++i){
int z=i;
for(int j=i;j<=n;++j)
if(fabs(p[z][i])<fabs(p[j][i]))
z=j;
swap(p[i],p[z]);
for(int j=2*n;j>=i;--j)
p[i][j]/=p[i][i];
for(int j=i+1;j<=n;++j)
for(int k=2*n;k>=i;--k)
p[j][k]-=p[i][k]*p[j][i];
}
matrix ans(n,n);
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
ans.a[i][j]=p[i][j+n];
return ans;
}
};
后缀自动机
int ch[N*2][26],pre[N*2],len[N*2],last=1,k=1;
void Append(int c)
{
int p=last;last=++k;len[k]=len[p]+1;
for(;!ch[p][c]&&p;p=pre[p])
ch[p][c]=k;
if(!p){pre[k]=1;return;}
int np=ch[p][c];
if(len[np]==len[p]+1){pre[k]=np;return;}
int q=++k;
memcpy(ch[q],ch[np],sizeof(ch[q]));
pre[q]=pre[np];len[q]=len[p]+1;
pre[np]=pre[last]=q;
for(;ch[p][c]==np;p=pre[p])
ch[p][c]=q;
}
Dinic
int dis[N],head[N],Next[E],adj[E],k=1,S,T;
int que[N],now[N];
long long cap[E];
void addedge(int u,int v,long long w)
{
Next[++k]=head[u],head[u]=k,adj[k]=v,cap[k]=w;
Next[++k]=head[v],head[v]=k,adj[k]=u,cap[k]=0;
}
bool BFS()
{
int i,l,r;
memset(dis,-1,sizeof(dis));
que[l=r=1]=S;
dis[S]=0;
while(l<=r)
{
for(i=head[que[l]];i;i=Next[i])
if(dis[adj[i]]==-1&&cap[i])
{
dis[adj[i]]=dis[que[l]]+1;
que[++r]=adj[i];
}
++l;
}
return (dis[T]!=-1);
}
long long DFS(int i,long long f)
{
if(i==T)
return f;
long long ans=0;
int j;
for(j=now[i];j;now[i]=j=Next[j])
{
long long tmp;
if(dis[adj[j]]==dis[i]+1&&cap[j]&&(tmp=DFS(adj[j],min(cap[j],f))))
{
cap[j]-=tmp;
cap[j^1]+=tmp;
f-=tmp;
ans+=tmp;
if(!f) break;
}
}
return ans;
}
long long Dinic()
{
long long ans=0;
while(BFS())
{
memcpy(now,head,sizeof(head));
ans+=DFS(S,inf);
}
return ans;
}
SPFA费用流
int head[N],Next[E],adj[E],cap[E],cost[E];
int q[N*20],pre[N],vis[N],now[N];
int flow,S,T,num=1;
long long d[N];
void addedge(int u,int v,int f,int w)
{
Next[++num]=head[u],head[u]=num,adj[num]=v,cap[num]=f,cost[num]=w;
Next[++num]=head[v],head[v]=num,adj[num]=u,cap[num]=0,cost[num]=-w;
}
bool SPFA()
{
int i,l,r;
q[l=r=1]=S;
vis[S]=1;
memset(d,0x7f,sizeof(d));
d[S]=0;
while(l<=r)
{
for(i=head[q[l]];i;i=Next[i])
if(cap[i]&&d[adj[i]]>d[q[l]]+cost[i])
{
d[adj[i]]=d[q[l]]+cost[i];
if(!vis[adj[i]])
{
vis[adj[i]]=1;
q[++r]=adj[i];
}
}
vis[q[l]]=0;
++l;
}
return (d[T]<1<<30);
}
bool dfs(int i,int f)
{
if(i==T)
{
flow=f;
return true;
}
if(vis[i])
return false;
int j;
vis[i]=1;
for(j=now[i];j;now[i]=j=Next[j])
if(cap[j]&&d[adj[j]]==d[i]+cost[j]&&dfs(adj[j],min(f,cap[j])))
{
cap[j]-=flow;
cap[j^1]+=flow;
vis[i]=0;
return true;
}
vis[i]=0;
return false;
}
long long ans,ansf;
void minmax()
{
while(SPFA())
{
memcpy(now,head,sizeof(now));
while(dfs(S,inf))
ans+=flow*d[T],ansf+=flow;
}
}
多项式合集
namespace poly{
int R[N*4];
long long qpow(long long a,long long b){
long long ans=1;
while(b){
if(b&1)
ans=ans*a%M;
a=a*a%M;
b>>=1;
}
return ans;
}
long long wn[N*4],iwn[N*4],inv[N*4],fac[N*4],ifac[N*4];
void init(int E){
int i;
iwn[E/2]=wn[E/2]=1;
long long s1=qpow(3,(M-1)/E);
long long s2=qpow(s1,M-2);
for(i=E/2+1;i<E;++i){
wn[i]=wn[i-1]*s1%M;
iwn[i]=iwn[i-1]*s2%M;
}
for(i=E/2-1;i;--i){
wn[i]=wn[i<<1];
iwn[i]=iwn[i<<1];
}
ifac[0]=fac[0]=inv[1]=1;
for(i=2;i<E;++i)
inv[i]=inv[M%i]*(M-M/i)%M;
for(i=1;i<E;++i){
ifac[i]=inv[i]*ifac[i-1]%M;
fac[i]=fac[i-1]*i%M;
}
}
unsigned long long ccc[N*4];
void NTT(long long *f,int lim,int op){
int i,j,k;
for(i=0;i<lim;++i){
R[i]=(R[i>>1]>>1)|(i&1?lim>>1:0);
if(R[i]<i)
swap(f[R[i]],f[i]);
}
for(i=0;i<lim;++i)
ccc[i]=(f[i]%M+M)%M;
for(i=1;i<lim;i<<=1)
for(j=0;j<lim;j+=(i<<1))
for(k=j;k<j+i;++k){
long long w=(op==1?wn[k-j+i]:iwn[k-j+i]);
unsigned long long p=ccc[k+i]*w%M;
ccc[k+i]=ccc[k]+M-p;
ccc[k]+=p;
}
for(i=0;i<lim;++i)
f[i]=ccc[i]%M;
if(op==-1){
long long inv=qpow(lim,M-2);
for(i=0;i<lim;++i)
f[i]=f[i]*inv%M;
}
}
long long ta[N*4],tb[N*4];
void mult(long long *a,int n,long long *b,int m,long long *c){
int lim=1;
while(lim<n+m)
lim<<=1;
copy(a,a+n,ta);
copy(b,b+m,tb);
for(int i=n;i<lim;++i)
ta[i]=0;
for(int i=m;i<lim;++i)
tb[i]=0;
NTT(ta,lim,1);
NTT(tb,lim,1);
for(int i=0;i<lim;++i)
ta[i]=ta[i]*tb[i]%M;
NTT(ta,lim,-1);
copy(ta,ta+lim,c);
}
long long tmp[N*4],tans[N*4];
void Getinv(long long *a,long long *ans,int lim){
ans[0]=qpow(a[0],M-2);
for(int i=1;i<lim;i<<=1){
for(int j=i;j<(i<<2);++j)
ans[j]=tans[j]=tmp[j]=0;
for(int j=0;j<(i<<1);++j)
tmp[j]=a[j];
for(int j=0;j<i;++j)
tans[j]=ans[j];
NTT(tmp,i<<2,1);
NTT(tans,i<<2,1);
for(int j=0;j<(i<<2);++j)
tmp[j]=tmp[j]*tans[j]%M*tans[j]%M;
NTT(tmp,i<<2,-1);
for(int j=0;j<(i<<1);++j)
ans[j]=(2*ans[j]-tmp[j])%M;
}
}
long long tinv[N*4];
void Getln(long long *a,long long *ans,int n){
for(int i=0;i<n-1;++i)
ans[i]=a[i+1]*(i+1)%M;
Getinv(a,tinv,n);
mult(ans,n-1,tinv,n,ans);
for(int i=n;i>=1;--i)
ans[i]=ans[i-1]*inv[i]%M;
ans[0]=0;
}
long long tln[N*4];
void Getexp(long long *a,long long *ans,int n){
ans[0]=1;
for(int i=1;i<n;i<<=1){
for(int j=i;j<(i<<1);++j)
ans[j]=0;
Getln(ans,tln,i<<1);
for(int j=0;j<(i<<1);++j)
tln[j]=-tln[j]+a[j];
++tln[0];
mult(ans,i,tln,i<<1,ans);
}
}
void Getroot(long long *a,long long *ans,int n){
ans[0]=1;
for(int i=1;i<n;i<<=1){
fill(ans+i,ans+(i<<1),0);
Getinv(ans,tinv,i<<1);
mult(tinv,i<<1,a,i<<1,tinv);
for(int j=0;j<(i<<1);++j)
ans[j]=(ans[j]+tinv[j])*inv[2]%M;
}
}
long long ttln[N*4];
void Getpow(long long *a,long long *ans,int n,int m){
Getln(a,ttln,m);
for(int i=0;i<m;++i)
ttln[i]=ttln[i]*n%M;
Getexp(ttln,ans,m);
}
};
杜教筛
const int N=3000000;
int prime[N/5],vis[N+5],phi[N+5],mu[N+5],k,i;
long long sm[N+5],sp[N+5];
long long smu[1000005],sphi[1000005];
long long Smu(int m)
{
if(m<=N)
return sm[m];
int t=n/m;
if(smu[t])
return smu[t];
smu[t]=1;
for(int l=2,r;l<=m;l=r+1)
{
r=m/(m/l);
smu[t]-=(r-l+1)*Smu(m/l);
}
return smu[t];
}
long long Sphi(int m)
{
if(m<=N)
return sp[m];
int t=n/m;
if(sphi[t])
return sphi[t];
sphi[t]=1ll*m*(m+1)/2;
for(int l=2,r;l<=m;l=r+1)
{
r=m/(m/l);
sphi[t]-=(r-l+1)*Sphi(m/l);
}
return sphi[t];
}
void xxs()
{
int i,j;
mu[1]=phi[1]=1;
for(i=2;i<=N;++i)
{
if(!vis[i])
{
mu[i]=-1;
phi[i]=i-1;
vis[i]=1;
prime[++k]=i;
}
for(j=1;i*prime[j]<=N;++j)
{
int t=i*prime[j];
vis[t]=1;
if(i%prime[j]==0)
{
mu[t]=0;
phi[t]=phi[i]*prime[j];
break;
}
else
{
mu[t]=mu[i]*mu[prime[j]];
phi[t]=phi[i]*phi[prime[j]];
}
}
}
for(i=1;i<=N;++i)
{
sm[i]=sm[i-1]+mu[i];
sp[i]=sp[i-1]+phi[i];
}
}
Dijkstra
int k,head[N],Next[N*2],adj[N*2],leng[N*2],vis[N],n;
long long d[N];
struct str{
long long d;
int x;
};
bool operator <(str a,str b)
{
return a.d>b.d;
}
priority_queue<str> q;
void Push(int u,int v,int w)
{
Next[++k]=head[u];
head[u]=k;
adj[k]=v;
leng[k]=w;
}
void Dij(int S)
{
int i,j;
for(i=1;i<=n;++i)
{
d[i]=1000000000000000000ll;
vis[i]=0;
}
d[S]=0;
q.push((str){0,S});
while(!q.empty())
{
str x=q.top();
q.pop();
if(vis[x.x])
continue;
vis[x.x]=1;
for(j=head[x.x];j;j=Next[j])
if(d[adj[j]]>d[x.x]+leng[j])
{
d[adj[j]]=d[x.x]+leng[j];
q.push((str){d[adj[j]],adj[j]});
}
}
}
主席树（以单点加为例）
int ch[N*20][2],tree[N*20],k;
void pushup(int i)
{
tree[i]=tree[ch[i][0]]+tree[ch[i][1]];
}
void modify(int i,int l,int r,int x,int y)
{
if(l==r)
{
++k;
tree[k]=tree[i]+y;
return;
}
int mid=l+r>>1;
int u=++k;
if(mid>=x)
{
ch[u][1]=ch[i][1];
ch[u][0]=k+1;
modify(ch[i][0],l,mid,x,y);
pushup(u);
}
else
{
ch[u][0]=ch[i][0];
ch[u][1]=k+1;
modify(ch[i][1],mid+1,r,x,y);
pushup(u);
}
}
void Build(int i,int l,int r)
{
if(l==r)
return;
int mid=l+r>>1;
ch[i][0]=++k;
Build(ch[i][0],l,mid);
ch[i][1]=++k;
Build(ch[i][1],mid+1,r);
}
int Query(int i,int l,int r,int x)
{
if(l==r)
return tree[i];
int mid=l+r>>1;
if(mid>=x)
return Query(ch[i][0],l,mid,x);
else
return Query(ch[i][1],mid+1,r,x);
}
部分几何模板
struct str{
int x,y;
}q[500005];
struct pt{
double x,y;
};
pt operator -(pt a,pt b)
{
return (pt){a.x-b.x,a.y-b.y};
}
pt operator +(pt a,pt b)
{
return (pt){a.x+b.x,a.y+b.y};
}
double area(pt x,pt y)
{
return fabs((x.x*y.y-x.y*y.x)/2);
}
double dot(pt x,pt y)
{
return x.x*y.x+x.y*y.y;
}
double dis(pt x,pt y)
{
return sqrt((x.x-y.x)*(x.x-y.x)+(x.y-y.y)*(x.y-y.y));
}
double D(pt x,pt y,pt a)//点到线段距离
{
if(dot(a-x,y-x)<0||dot(a-y,x-y)<0)
return min(dis(x,a),dis(y,a));
return area(x-a,y-a)*2/dis(x,y);
}
批量生成输出模板
#include<bits/stdc++.h>
using namespace std;
int i;
string nm="string";
void OP(int x)
{
string c="sub"+to_string(x)+"_"+nm+to_string(++id[x]);
system(("copy "+c+".in "+nm+".in").data());
system((nm+".exe").data());
system((string("copy ")+nm+".out "+c+".out").data());
}
int main()
{
for(i=1;i<=10;++i)
OP(1);
}
咕咕咕……
