哇怎么有这么多板子啊

快读

int read()
{
    int num=0;bool flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-')flag=0;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-'0';
    return flag?num:-num;
}

二分

int erfen()
{
	double mid,left=0,right=maxn;
	while(left+1<right)
	{
		mid=(left+right)/2;
		if(check(mid)) left=mid;
		else right=mid;
	}
	if(check(mid)) return left;
	else return right;
}

堆

priority_queue< int >da //一般默认为大根堆 
priority_queue< int ,vector< int >,greater< int > >xiao//小根堆 
.push()	//元素入队
.pop() //队首元素出队
.top() //取队首元素
.empty() //如果队列为空，则返回true（1），否则返回false（0）
.size() //返回优先队列中拥有的元素个数

线式筛

int v[maxn],prime[maxn];
int getprimes(int n)
{
	int m=0;
	for(int y=2;y<=n;y++)
	{
		if(v[y]==0) {v[y]=y;prime[++m]=y;}
		for(int i=1;i<=m;i++)
		{
			int x=prime[i];
			if(x>v[y]) break;
			if(x*y>n) break;
			int z=x*y;
			v[z]=x;
		}
	}
	return m;
}

gcd

long long gcd(long long x,long long y){
	if(x<y) swap(x,y);
	if(y==0) return x;
	else return gcd(y,x%y);
}

树状数组

int lowbit(int x){return x&-x;}//lowbit
void add(int x,int y){while(x<MAXN)c[x]+=y,x+=lowbit(x);}//插入
int work(int x)//查询
{
	int sum=0;
	while(x>0) sum+=c[x],x-=lowbit(x);
	return sum;
}

线段树

#define N 200005
#define LL long long 
using namespace std;

int n,m,arr[N];

struct Seg_Tree
{
	LL sum[N<<2],laz[N<<2],tmax[N<<2];

	const LL INF = 0x3f3f3f3f3f3f3f3f;

	inline void pushup(int p)
	{
		sum[p]=sum[p<<1]+sum[p<<1|1];
		tmax[p]=max(tmax[p<<1],tmax[p<<1|1]);
	}

	inline void spread(int p,int l,int r)
	{
		if(!laz[p]) return ;
		int mid=(l+r)>>1;
		sum[p<<1]+=laz[p]*(mid-l+1);
		sum[p<<1|1]+=laz[p]*(r-mid);
		laz[p<<1]+=laz[p];
		laz[p<<1|1]+=laz[p];
		laz[p]=0;
	}

	void build(int p,int l,int r)
	{
		if(l==r) return (void)(sum[p]=tmax[p]=arr[l]);
		int mid=(l+r)>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
	}

	inline LL query_max(int p,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R) return tmax[p];
		spread(p,l,r);
		int mid=(l+r)>>1;
		LL res=-INF;
		if(L>=mid) res=query_max(p<<1,l,mid,L,R);
		if(R<mid) res=max(res,query_max(p<<1|1,mid+1,r,L,R));
		return res;
	}

	inline LL query_sum(int p,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R) return sum[p];
		spread(p,l,r);
		int mid=(l+r)>>1;
		LL res=0;
		if(L>=mid) res+=query_sum(p<<1,l,mid,L,R);
		if(R<mid) res+=query_sum(p<<1|1,mid+1,r,L,R);
		return res;
	}

	inline void add(int p,int l,int r,int L,int R,LL k)
	{
		if(L<=l&&r<=R) return (void)(sum[p]+=k*(r-l+1),laz[p]+=k);
		spread(p,l,r);
		int mid=(l+r)>>1;
		if(L>=mid) add(p<<1,l,mid,L,R,k);
		if(R<mid) add(p<<1|1,mid+1,r,L,R,k);
		pushup(p);
	}
}tr;

神奇六函数

int add(int a,int b,int p=mod){return a+b>=p?a+b-p:a+b;}
int sub(int a,int b,int p=mod){return a-b<0?a-b+p:a-b;}
int mul(int a,int b,int p=mod){return (LL)a*b%p;}
void sadd(int &a,int b,int p=mod){a=add(a,b,p);}
void ssub(int &a,int b,int p=mod){a=sub(a,b,p);}
void smul(int &a,int b,int p=mod){a=mul(a,b,p);}

求一个数的欧拉函数

ll eular(ll n)
{
	ll ans=n;
	for(int i=2;i*2<=n;i++)
	{
		if(n%i==0)
		{
			ans=ans/i*(i-1);
			while(n%i==0)  n/=i;
		}
	}
	if(n>1) ans=ans/n*(n-1);
	return ans;
}

火箭头

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

随机数

int random(int x){return (long long)rand()*rand()%x;}

快速幂

int ksm(int a,int b,int res)
{
	while(b){if(b&1)res=res*a%Mod;a=a*a%Mod;b>>=1;}
    return res;
}

组合

void ycl()
{
	jc[0]=1;for(int i=1;i<=N;i++)jc[i]=(jc[i-1]*i)%Mod;
	ny[N]=ksm(jc[N],Mod-2);
	for(int i=N-1;i>=0;i--)ny[i]=(ny[i+1]*(i+1))%Mod;
}
int ksm(int a,int b,int res)
{
	while(b){if(b&1)res=res*a%Mod;a=a*a%Mod;b>>=1;}
    return res;
}
int C(int x,int y)
{
	if(y>x) return 0;
	return jie[x]*ny[y]%Mod*ny[x-y]%Mod;
}

对拍

#include<iostream>
#include<windows.h>
using namespace std;
int main()
{
    while(1)
    {
        system("未命名2.exe > 未命名2.txt");//2是随机数 
        system("未命名5.exe < 未命名2.txt > 未命名5.txt");//5,6是程序 
        system("未命名6.exe < 未命名2.txt > 未命名6.txt");
        if(system("fc 未命名5.txt 未命名6.txt"))   break;
    }
    return 0;
}

随机数

#include <bits/stdc++.h>
using namespace std;
int random(int n) {return rand()*rand()%n;}
int main()
{
	cout<<random(50)<<' '<<random(50);
	return 0;
}