模板记录——赛前准备
模板大法好
- 0.STL操作
- vector 动态数组
- String 字符串类型
- stack 栈（先进后出）
- queue 队列（先进先出，公平原则）
- set 集合（去重性，有自动排序的功能）
- map 映射（映射，去重性，有自动排序的功能）
- Struct 结构体与stl的结合（排序）
- 1.素数
- 2.并查集
- （2）种类并查集
- （3）区间并查集
- （4）带权并查集
- 3.RMQ
- 4.欧拉函数
- （1）求欧拉函数
- （2）多次幂下的扩展欧拉降幂
- 5.最长上升子序列（最长下降）
- 6.逆元
- 7.割边、割点
- 8.双联通分量
- 9.LCA
- 10.SG
- 11.扩展欧几里得
- 12.快读/快写
- 13.退火
- 14.拓扑排序
- 15.字符串hash
- 16.卡特兰数
- 17.斯特林数
- 18.容斥
- 19.鸽笼原理
- 20.区间dp
- 21.floyd
- 22.dijkstra
- 23.SPFA
- 24.Dinic模板
- 25.最小生成树
- 26.树的直径
- 27.强联通分量
- 28.高精度
- 29.约瑟夫
- 30.母函数
- 31.背包dp
- 32.附件
0.STL操作
vector 动态数组
头文件
#include 定义vector数组
## 定义int型数组
vector <int> a; ## a为空
vector <int> b(a); ## 用a定义b
vector <int> a(100) ; ## a有100个为0的元素
vector <int> a(100, 6); ## a有100个为6的元素
## 定义string型数组
vector <string> a(10," null"); ## 10个值为null的元素
vector <string> vec(10,"hello"); ## 10个值为hello的元素
vector <string> b(a. begin(), a. end()); ## b是a的复制
## 定义结构型数组
struct point { int x, y; };
vector <point> a;
## 定义二维数组
vector <point> a[maxn]; ## 行静态，列动态
访问方式
## 下标访问
cout << a[i] << endl;
## 指针访问，用于以下情况
cout << *a.begin() << endl;
cout << *a.end() << endl;
## 迭代器访问
vector<int>::iterator it;
for(it=vec.begin();it!=vec.end();it++)
cout<<*it<<endl;
## 指针移动访问（最好别用，优先用迭代器，这个方法不知道合不合法，其实和下标访问区别不大）
vector<int> *p = &a;
for(int i = 0;i < a.size();i++)
cout << (*p)[i] << endl;
常规操作（一些自带的函数）
基础函数
a.push_back(); ## 尾部添加元素
a.size(); ## 返回元素个数大小
a.empty(); ## 返回是否为空，bool值
a.resize(); ## 改变数组大小，变小删除后面元素，变大自动补0
a.clear(); ## 清空
————————————————————————————————————————————————————————————————————————————————————————————————————
插入与删除
a.insert(a.begin() + i,k); ## 在下标为i的元素前插入k
a.insert(a.end(),k,m); ## 尾部插入k个m
a.pop_back(); ## 删除尾部元素
a.erase(a.begin() + i); ## 删除下标为i的元素（下标为2）
a.erase(a.begin() + i,a.begin() + j); ## 删除区间[i,j - 1]内的元素
————————————————————————————————————————————————————————————————————————————————————————————————————
翻转与排序
reverse(a.begin() + i,a.begin() + j); ## 翻转区间[i,j - 1]内的元素
sort(a.begin() + i,a.begin() + j); ## 对区间[i,j - 1]内的元素排序
可直接用的比较函数
less（降序）
greater（升序）
————————————————————————————————————————————————————————————————————————————————————————————————————
寻找
vector<int>::iterator result = find(L.begin( ) + i,L.begin( ) + j,m); ## 在区间[i,j - 1]内寻找m
cout << result - a.begin() << endl; ## 输出m值的下标位置
String 字符串类型
头文件
#include 定义String
string str ## 生成空串
string s = "12346789"; ## 直接赋值定义
string s(a) ## 以a定义s
string s(a,strbegin) ## 以a从strbegin到结尾的串定义s,且strbegin只能为下标，不能为地址
string s(a,strbegin,strlen) ## 以a从strbegin开始长度为strlen的串定义s,且strbegin只能为下标，不能为地址
string s(n,c) ## 生成num个c字符的字符串
访问方式
## 下标访问
cout << s[i] << endl;
## 指针访问，用于以下情况
cout << *s.begin() << endl;
cout << *s.end() << endl;
## 迭代器访问
string::iterator it;
for(it = s.begin();it != s.end();it++)
cout << *it << endl;
常规操作（一些自带的函数）
运算符的直接使用
+： 尾部添加（字符字符串皆可）
>： 直接比较大小（按字典循序，只能和字符串做比较）
<： 同上
>=： 同上
<=： 同上
————————————————————————————————————————————————————————————————————————————————————————————————————
基础函数
s.append(a); ## 将a添加到s尾部，a只能为字符串
s.length(); ## 返回s的长度（及大小）
s.size(); ## 返回s的大小（及长度）
s.empty(); ## 返回s是否为空，返回值为bool类型
————————————————————————————————————————————————————————————————————————————————————————————————————
插入、删除、替换
s.insert(s.begin() + i,a); ## 在下标为i的元素前添加a，a只能为字符
s.erase(s.begin() + i); ## 删除下标为i的元素
s.erase(s.begin() + i,s.begin() + j); ## 删除区间[i,j - 1]内的元素
s.replace(strbegin,strlen,a); ## 从下标strbegin开始长度为strlen的字符替换为a，a只能为字符串
————————————————————————————————————————————————————————————————————————————————————————————————————
翻转与排序
reverse(s.begin() + i,s.begin() + j); ## 翻转区间[i,j - 1]内的元素
sort(s.begin() + i,s.begin() + j); ## 对区间[i,j - 1]内的元素排序
可直接用的比较函数
less（降序）
greater（升序）
————————————————————————————————————————————————————————————————————————————————————————————————————
寻找与比较
s.find(a) ## 在s中寻找a（a可以为字符串也可以为字符），如果找到返回找到的第一个下标的值，不能则返回2^32 - 1
s.rfind(a) ## 在s的末尾开始找a，其他同上
s.find(a,strindex) ## 在s下标为strindex的地方开始找a
s.compare(a) ## 将s与a比较（字典循序），a只能为字符串，大于返回1，等于返回0，小于返回-1
stack 栈（先进后出）
头文件
#include 定义stack
stack <int> a;
访问方式
对于stack而言，中间的元素是无法访问的，只能通过a.top()访问栈顶元素
a.top();
常规操作（一些自带的函数）
基础函数
a.push(x); # 将x放到栈顶
a.pop(); # 删除栈顶元素
a.size(); # 返回栈内元素个数
a.empty(); # 返回栈是否为空
由于栈的使用对空间占用较大（深度大了不能及时释放），所以一下两点可以解决
1.在程序中调用大系统的栈，依赖于系统和编译器（不推荐）
2.手工写栈（没试过，但感觉数组可以实现，自己封装一下应该就ok）
queue 队列（先进先出，公平原则）
头文件
#include 定义queue
queue <int> a;
访问方式
同理，对于queue而言，中间的元素是无法访问的，只能通过a.front()访问栈顶元素
a.front();
常规操作（一些自带的函数）
基础函数
a.push(x); # 将x放到队尾
a.pop(); # 删除队首元素
a.back(); # 返回队尾元素
a.size(); # 返回队列内元素个数
a.empty(); # 返回队列是否为空
关于优先队列内容与队列高度相似（除了访问队首要使用 a.top()，其他并无不同），关键在于如何定义排序规则，在下面的Struct 结构体与stl的结合中有相关赘述（只是板块分的不太好），此处就不再说了。
set 集合（去重性，有自动排序的功能）
头文件
#include 定义set
set <int> a;
访问方式
迭代器访问
set <int> :: iterator it;
for(it = a.begin();it != a.end();it++){
cout << *it << endl;
}
常规操作（一些自带的函数）
基础函数
a.insert(x); # 插入x元素
a.erase(a.begin()); # 注意此处函数内要填迭代器，a.begin()实质上貌似就是迭代器
a.clear(); # 清空
a.empty();
a.size();
a.find(k); # 返回一个迭代器，指向键值k
a.lower_bound(k); # 返回一个迭代器，指向键值不小于k的第一个元素
a.upper_bound(k); # 返回一个迭代器，指向键值大于k的第一个元素
multiset为能容纳相同元素的集合，因不了解（用的少了当然不知道），暂不做记录
EX1：set_union(A.begin(),A.end(),B.begin(),B.end(),inserter( C1 , C1.begin() ) );前四个参数依次是第一的集合的头尾，第二个集合的头尾。第五个参数的意思是将集合A、B取合集后的结果存入集合C中。
EX2：set_union(A.begin(),A.end(),B.begin(),B.end(),ostream_iterator(cout," “));这里的第五个参数的意思是将A、B取合集后的结果直接输出，（cout," "）双引号里面是输出你想用来间隔集合元素的符号或是空格。
set里面有set_intersection（取集合交集）、set_union（取集合并集）、set_difference（取集合差集）、set_symmetric_difference（取集合对称差集）等函数。
map 映射（映射，去重性，有自动排序的功能）
头文件
#include
定义map
map <int,int> a;
赋值
a[x]=c;
访问方式
没研究出来，打扰了
}
常规操作（一些自带的函数）
基础函数
a.insert(x); # 存在这个东西，但写起来贼麻烦，直接用赋值即可
a.erase(a.begin()); # 注意此处函数内要填迭代器，a.begin()实质上貌似就是迭代器
a.clear(); # 清空
a.empty();
a.size();
a.find(k); # 返回一个迭代器，指向键值k 找不到就map::end()
multimap存在，但不知道怎么用，暂不整理
Struct 结构体与stl的结合（排序）
vector
自己写cmp函数
bool GreaterSort (Node a,Node b) { return (a.x>b.x); }
bool LessSort (Node a,Node b) { return (a.x<b.x); }
sort(a.begin(),a.end(),GreaterSort);
————————————————————————————————————————————————————————————————————————————————————————————————————
重载<运算符
struct node ## 内联写法
{
int x, y;
bool operator < (const node & o) const
{
return x<o.x;
}
};
priority_queue
调用默认排序函数
priority_queue<int,vector<int>,greater<int> >q1;
priority_queue<int,vector<int>,less<int> >q1;
————————————————————————————————————————————————————————————————————————————————————————————————————
自定义比较函数
struct cmp1{ 重载（）运算符
bool operator()(node a,node b)
{
if(a.x == b.x) return a.y > b.y;
return a.x > a.x;
}
};
priority_queue<node,vector<node>,cmp1> q;
————————————————————————————————————————————————————————————————————————————————————————————————————
重载<运算符
struct node{
int x,y;
friend bool operator<(node a,node b) ## 必须为友元关系
{
return a.x>b.x;
}
};
priority_queue <node> q;
set
调用默认排序函数
set<int,greater<int> > Set;
set<int,less<int> > Set;
————————————————————————————————————————————————————————————————————————————————————————————————————
自定义比较函数
struct intcmp {
bool operator() (const int& a, const int& b) const{
return a > b;
}
};
struct strcmp
{
bool operator() (const string& a, const string& b) const {
return a < b;
}
};
set<int, intcmp> Set
————————————————————————————————————————————————————————————————————————————————————————————————————
重载<运算符
struct node
{
int x,y;
bool operator < (const node &s) const {
if(x!=s.x) return y < s.y;
else return x<s.x;
}
};
set <node> Set;
map
map也有自动排序的特性，但现目前来讲没有特别用到的地方，暂不整理
总结：
由于vector支持sort排序，大多是时候使用sort的自定义排序会较为便捷。
而set和priority_queue无法使用sort排序，个人角度而言，重载<运算符可能使用起来较为方便。
一些备注：
1.如不使用写比较函数的方式，重载的都是 < 运算符。
2.而使用比较函数的话，除了vector，都得重载 () 并将比较函数放入定义中。
3.比较值得注意的是，priority_queue的 < 运算符重载必须得写成友元。
1.素数
线性筛（欧拉筛）
取出素数版本外加判断表
int p[maxn]; 保存素数
bool v[maxn]; 判断是否为素数，0为素，1反之
void p_table(int n){
memset(p,0,sizeof(p));
memset(v,0,sizeof(v));
v[1] = v[0] = 1;
for(int i = 2;i <= n;++i){
if(!v[i]) p[++p[0]] = i;
for(int j = 1;j <= p[0] && i*p[j] <= n;++j){
v[i*p[j]] = 1;
if(i % p[j] == 0) break;
}
}
return ;
}
单纯取出素数筛
int p[maxn];
void p_table(int n){
memset(p,0,sizeof(p));
for(int i = 2;i <= n;++i){
if(!p[i]) p[++p[0]] = i;
for(int j = 1;j <= p[0] && i*p[j] <= n;++j){
p[i*p[j]] = 1;
if(i % p[j] == 0) break;
}
}
return ;
}
区间筛
#include 区间筛模板2
#include 大素数模板
#include2.并查集
裸版查找
int find(int k){
return pre[k] = pre[k] == k ?k :find(pre[k]);
}
带权更新查找
int find(int x){
if(pre[x] == x) return x;
int t = pre[x];
pre[x] = find(pre[x]);
ans[x] += ans[t];
return pre[x];
}
（2）种类并查集
对立面并查集
#include poj-1703
三种及以上环形关系并查集（赋权）
#include poj 1182
三种及以上环状关系（扩展域）
#include poj 1182 即多倍数组
（3）区间并查集
** 本质思想，维护根节点权值为0，边权转点权差**
#include hdu 3038 How Many Answers Are Wrong
（4）带权并查集
结点权值和集合权值
#include poj 1988
** 集合带权变形**
#include 百度之星（普通权值变非冲突合集（权值））
3.RMQ
基础RMQ（区间最大最小）
int n,query;
int num[MAXN];
int F_Min[MAXN][20],F_Max[MAXN][20];
void Init()
{
for(int i = 1; i <= n; i++)
{
F_Min[i][0] = F_Max[i][0] = num[i];
}
for(int i = 1; (1<<i) <= n; i++) //按区间长度递增顺序递推
{
for(int j = 1; j+(1<<i)-1 <= n; j++) //区间起点
{
F_Max[j][i] = max(F_Max[j][i-1],F_Max[j+(1<<(i-1))][i-1]);
F_Min[j][i] = min(F_Min[j][i-1],F_Min[j+(1<<(i-1))][i-1]);
}
}
}
int Query_max(int l,int r)
{
int k = (int)(log(double(r-l+1))/log((double)2));
return max(F_Max[l][k], F_Max[r-(1<<k)+1][k]);
}
int Query_min(int l,int r)
{
int k = (int)(log(double(r-l+1))/log((double)2));
return min(F_Min[l][k], F_Min[r-(1<<k)+1][k]);
}
区间最频繁次数（只有模板，尚未理解
#include **二维RMQ（O(nmlog(m))-O(n)）
#include
#include 4.欧拉函数
（1）求欧拉函数
直接求解欧拉函数
int euler(int n){ //返回euler(n)
int res=n,a=n;
for(int i=2;i*i<=a;i++){
if(a%i==0){
res=res/i*(i-1);//先进行除法是为了防止中间数据的溢出
while(a%i==0) a/=i;
}
}
if(a>1) res=res/a*(a-1);
return res;
先筛选素数，然后实现欧拉函数打表
bool boo[50000];
int p[20000];
void prim()
{
memset(boo,0,sizeof(boo));
boo[0]=boo[1]=1;
int k=0;
for(int i=2; i<50000; i++)
{
if(!boo[i])
p[k++]=i;
for(int j=0; j<k&&i*p[j]<50000; j++)
{
boo[i*p[j]=1;
if(!(i%p[j]))
break;
}
}
}//筛选法打表
int phi(int n)
{
int rea=n;
for(int i=0; p[i]*p[i]<=n; i++)//对于一些不是素数的可不遍历
if(n%p[i]==0)
{
rea=rea-rea/n;
do
n/=p[i];
while(n%p[i]==0);
}
if(n>1)
rea=rea-rea/n;
return rea;
}
结合版
#include递推求欧拉函数
for(i=1; i<=maxn; i++)
p[i]=i;
for(i=2; i<=maxn; i+=2)
p[i]/=2;
for(i=3; i<=maxn; i+=2)
if(p[i]==i)
{
for(j=i; j<=maxn; j+=i)
p[j]=p[j]/i*(i-1);
}
（2）多次幂下的扩展欧拉降幂
细节mod（解决mod选择问题）
ll Mod(ll x, ll mod){
return x < mod ? x : x % mod + mod;
}
super_log
#include多重节是相同的，不同的情况下，可以通过数组记录操作
附上另一题
hdu 2837
#include5.最长上升子序列（最长下降）
nlogn
#include 洛谷 导弹拦截
记录一道例题（双向区分dp）：
#include POJ - 1239
6.逆元
拓展欧几里得
LL exgcd(LL a,LL b,LL &x,LL &y)//扩展欧几里得算法
{
if(b==0)
{
x=1,y=0;
return a;
}
LL ret=exgcd(b,a%b,y,x);
y-=a/b*x;
return ret;
}
LL getInv(int a,int mod)//求a在mod下的逆元，不存在逆元返回-1
{
LL x,y;
LL d=exgcd(a,mod,x,y);
return d==1?(x%mod+mod)%mod:-1;
}
费马小定理求逆元
LL qkpow(LL a,LL p,LL mod)
{
LL t=1,tt=a%mod;
while(p)
{
if(p&1)t=t*tt%mod;
tt=tt*tt%mod;
p>>=1;
}
return t;
}
LL getInv(LL a,LL mod)
{
return qkpow(a,mod-2,mod);
}
递推求逆元
LL inv[mod+5];
void getInv(LL mod)
{
inv[1]=1;
for(int i=2;i<mod;i++)
inv[i]=(mod-mod/i)*inv[mod%i]%mod;
}
递归求逆元
LL inv(LL i)
{
if(i==1)return 1;
return (mod-mod/i)*inv(mod%i)%mod;
}
7.割边、割点
割点
#include 割边
#include 去一点求割点联通块数
#include 求割点联通块数
#include 8.双联通分量
点双（染点）
#include点双（染边）
#include 点双（染边加记录桥的数量）
#include 边双（找边）
#include 边双（染点）
#include 割边缩点后每个点的度数
#include割边缩点后求点的度数
#include割边缩点图上跑lca（扩展）
#include"cstdio"
#include"cstring"
#include"cstdlib"
#include"cmath"
#include"string"
#include"map"
#include"cstring"
#include"iostream"
#include"algorithm"
#include"queue"
#include"stack"
#define inf 0x3f3f3f3f
#define M 100009
#define eps 1e-8
#define INT int
using namespace std;
struct node
{
int u,v,next;
}edge[M*10],e[M*10];
stack<int>q;
int t,head[M],dfn[M],low[M],indx,cut[M*10],num,cnt,belong[M],use[M],suo[M],mark[M*10],pre[M],pp[M],ranks[M],ans;
void init()
{
t=0;
memset(head,-1,sizeof(head));
}
void add(int u,int v)
{
edge[t].u=u;
edge[t].v=v;
edge[t].next=head[u];
head[u]=t++;
}
void tarjan(int u,int id)//求桥
{
dfn[u]=low[u]=++indx;
q.push(u);
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(id==(i^1))continue;
if(!dfn[v])
{
tarjan(v,i);
low[u]=min(low[u],low[v]);
if(low[v]>dfn[u])
{
cut[++num]=i;
mark[i]=mark[i^1]=1;//存桥的编号，且把其进行标记
}
}
else
low[u]=min(low[u],dfn[v]);
}
}
void slove(int n)
{
num=indx=0;
memset(low,0,sizeof(low));
memset(dfn,0,sizeof(dfn));
memset(cut,0,sizeof(cut));
memset(mark,0,sizeof(mark));
for(int i=1;i<=n;i++)
{
if(!dfn[i])
tarjan(i,-1);
}
return ;
}
void dfs(int u,int tep)
{
use[u]=1;
suo[u]=tep;
for(int i=head[u];~i;i=edge[i].next)
{
if(mark[i])continue;
int v=edge[i].v;
if(!use[v])
dfs(v,tep);
}
}
void DFS(int u,int fa)
{
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(fa==v)continue;
pre[v]=u;
ranks[v]=ranks[u]+1;
DFS(v,u);
}
}
void LCA(int u,int v)
{
while(u!=v)
{
if(ranks[u]>ranks[v])
{
if(!pp[u])
{
ans++;
pp[u]=1;
}
u=pre[u];
}
else
{
if(!pp[v])
{
pp[v]=1;
ans++;
}
v=pre[v];
}
}
}
void litter(int n)
{
cnt=0;
memset(suo,0,sizeof(suo));
memset(use,0,sizeof(use));
for(int i=1;i<=num;i++)//缩点
{
int u=edge[cut[i]].u;
if(!suo[u])
{
dfs(u,++cnt);
}
int v=edge[cut[i]].v;
if(!suo[v])
dfs(v,++cnt);
e[i].u=u;
e[i].v=v;
}
// for(int i=1;i<=n;i++)
//printf("%d %d\n",i,suo[i]);
init();
for(int i=1;i<=num;i++)
{
int u=e[i].u;
int v=e[i].v;
add(suo[u],suo[v]);
add(suo[v],suo[u]);
}//把缩点后的图建成一棵树
memset(pre,-1,sizeof(pre));
ranks[1]=1;
DFS(1,1);
int Q;
cin>>Q;
int sum=0;
memset(pp,0,sizeof(pp));
while(Q--)
{
int a,b;
scanf("%d%d",&a,&b);
ans=0;
LCA(suo[a],suo[b]);
sum+=ans;
printf("%d\n",num-sum);
}
printf("\n");
}
int main()
{
int n,m,a,b,kk=1;
while(scanf("%d%d",&n,&m),n||m)
{
init();
for(int i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
add(a,b);
add(b,a);
}
slove(n);
printf("Case %d:\n",kk++);
litter(n);
}
return 0;
}
network
自己写的非缩点跑法
#include #include9.LCA
基础倍增法
#include 预处理与深度遍历结合
#include边带权LCA
#include LCA转RMQ
int head[maxn];
int first[maxn];//首次出现的下标
int dp[maxn*2][30];
bool vis[maxn];
bool ok[maxn];
int deep[maxn*2];//深度数组
int ver[maxn*2];//节点序列
int n,cnt,tot;
struct Edge{
int next;
int to;
}edge[maxn];
void addedge(int u, int v){
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void dfs(int u, int step){
vis[u] = true;
ver[tot] = u;
first[u] = tot;
deep[tot++] = step;
for(int i=head[u]; i!=-1; i=edge[i].next){
if(!vis[edge[i].to]){
dfs(edge[i].to,step+1);
ver[tot] = u;
deep[tot++] = step;
}
}
}
void st(int n){
for(int i=0; i<n; i++)
dp[i][0] = i;//保存的下标
for(int j=1; (1<<j)<=n; j++)
for(int i=0; i+(1<<j)-1<n; i++){
int a = dp[i][j-1];
int b = dp[i+(1<<(j-1))][j-1];
dp[i][j] = deep[a] < deep[b] ? a : b;
}
}
int rmq(int x, int y){
int k = (int)(log((y-x+1)*1.0)/log(2.0));
int a = dp[x][k];
int b = dp[y-(1<<k)+1][k];
if(deep[a] < deep[b]) return a;
return b;
}
int lca(int u, int v){
int x = first[u], y = first[v];//首次出现的下标
if(x > y) swap(x,y);
int ans = rmq(x,y);//得到的是下标
return ver[ans];
}
void init(){
cnt = tot = 0;
memset(head, -1, sizeof(head));
memset(vis, false, sizeof(vis));
memset(ok, false, sizeof(ok));
}
10.SG
//f[]：可以取走的石子个数
//sg[]:0~n的SG函数值
//hash[]:mex{}
int f[N],sg[N],hash[N];
void getSG(int n)
{
int i,j;
memset(sg,0,sizeof(sg));
for(i=1;i<=n;i++)
{
memset(hash,0,sizeof(hash));
for(j=1;f[j]<=i;j++)
hash[sg[i-f[j]]]=1;
for(j=0;j<=n;j++) //求mes{}中未出现的最小的非负整数
{
if(hash[j]==0)
{
sg[i]=j;
break;
}
}
}
}
11.扩展欧几里得
LL exgcd(LL a,LL b,LL &x,LL &y)
{
if(b==0)
{
x=1,y=0;
return a;
}
LL ret=exgcd(b,a%b,y,x);
y=y-a/b*x;
return ret;
}
12.快读/快写
LL Read()
{
LL i=0,f=1;
char c;
for(c=getchar();(c>'9'||c<'0')&&c!='-';c=getchar());
if(c=='-')
f=-1,c=getchar();
for(;c>='0'&&c<='9';c=getchar())
i=(i<<3)+(i<<1)+c-'0';
return i*f;
}
int read()
{
int x = 0, ch = getchar(), v = 1;
while(!isdigit(ch)){
if(ch == '-')
v = -1;
ch = getchar();
}
while(isdigit(ch)){
x = x * 10 + ch - '0';
ch = getchar();
}
return x * v;
}
void sc(LL x)
{
if(x>=10)
sc(x/10);
putchar(x%10+48);
}
13.退火
#include #include 以上最小球半径
#include 洛谷 平衡点
14.拓扑排序
dfs遍历找所有拓扑排序
#include 拓扑排序判环 && bfs拓扑排序
#include 15.字符串hash
找最长重复串
#include 16.卡特兰数
卡特兰数前几项为 : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, …
公式一：h(n)= h(0)h(n-1)+h(1)h(n-2) + … + h(n-1)h(0) (n>=2)
公式二：h(n)=h(n-1)(4n-2)/(n+1)
公式三：h(n)=C(2n,n)/(n+1) (n=0,1,2,…)
公式四：h(n)=c(2n,n)-c(2n,n-1)(n=0,1,2,…)
Catalan数的典型应用：
1.由n个+1和n个-1组成的排列中，满足前缀和>=0的排列有Catalan(N)种。
2.括号化问题。左括号和右括号各有n个时，合法的括号表达式的个数有Catalan(N)种。
3.有n+1个数连乘，乘法顺序有Catalan(N)种,相当于在式子上加括号。
4.n个数按照特定顺序入栈，出栈顺序随意，可以形成的排列的种类有Catalan(N)种。
5.给定N个节点，能构成Catalan(N)种种形状不同的二叉树。
6.n个非叶节点的满二叉树的形态数为Catalan(N)。
7.对于一个nn的正方形网格，每次只能向右或者向上移动一格，那么从左下角到右上角的不同种类有Catalan(N)种。
8.对于在n位的2进制中，有m个0，其余为1的catalan数为：C（n,m）-C(n,m-1)。
9.对凸n+2边形进行不同的三角形分割（只连接顶点对形成n个三角形）数为Catalan(N)。
10.将有2n个元素的集合中的元素两两分为n个子集，若任意两个子集都不交叉，那么我们称此划分为一个不交叉划分。此时不交叉的划分数是Catalan(N)。
11.n层的阶梯切割为n个矩形的切法数也是Catalan(N)。
12.在一个2n的格子中填入1到2n这些数值使得每个格子内的数值都比其右边和上边的所有数值都小的情况数也是Catalan(N)。
卡特兰数高精度递推打表
#include 卡特兰数取模打表
#include 究极加速打表
void catalan_table(){
catalan[0] = catalan[1] = 1;
f[1] = f[0] = 1;
inv[1] = 1;
for(ll i = 2;i <= 1000000;i++) inv[i] = (mod - mod/i) * inv[mod%i] % mod;
for(ll i = 2;i <= 1000000;i++){
catalan[i] = catalan[i - 1] * (4*i-2) % mod * inv[i+1] % mod;
f[i] = f[i - 1] * i % mod;
}
return;
}
17.斯特林数
第一类斯特林数打表
#include 
第二类斯特林数打表
#include 
贝尔数模板
const int maxn = 21;
ll Bell[maxn];
void init() {
ll T[maxn];
Bell[0] = 1;
Bell[1] = 1;
T[0] = 1;
for(int i = 2; i < maxn; i++) {
T[i - 1] = Bell[i - 1];
for(int j = i - 2; j >= 0; j--)
T[j] = T[j] + T[j + 1];
Bell[i] = T[0];
}
}
18.容斥
容斥模板
#include
int mult=1,cnt=0;
for(int j=0; j<num; j++) //循环prime中的每个元素
{
if(i & (1<<j))//要掌握&运算，与i的二进制的第j位比较，看是否为1，是则选中
{
cnt++;//记录集合中元素的个数
mult = lcm(mult,prime[j]);//是否要lcm看情况
}
}
if(cnt&1)//集合元素个数为奇数就加，否则减
ans += n/mult;
else
ans -= n/mult;
}
return n-ans;
}
int main()
{
cout<<solve();
return 0;
}
队列解决容斥
#include 19.鸽笼原理
#include 20.区间dp
枚举三个点点
先枚举前面的数（i），再枚举后面的数（j），最后枚举中间的分割线（c）（三重循环） 用i到c-1之间的数加上c到j的数再加上之前的得分，再将所有的值去最小。
f[i][j]=min(f[i][j],f[i][c−1]+f[c][j]+s[j]−s[i−1])
#include先枚举长度
先枚举长度（k），再枚举前面的数（i），最后枚举分割线（c），然后后面的数（j）就可以求出来了：
j=i+k−1
f[i][j]=min(f[i][j],f[i][c−1]+f[c][j]+s[j]−s[i−1])
#include先枚举长度，后枚举点
方法与前面的一样，但是f[i][j]表示的是从第i个开始后面的j个数
f[i][j]=min(f[i][j],f[i][c]+f[i+c][j−c]+s[i+j−1]−s[i−1])
#include21.floyd
求最小环
int val[maxn + 1][maxn + 1]; // 原图的邻接矩阵
inline int floyd(const int &n) {
static int dis[maxn + 1][maxn + 1]; // 最短路矩阵
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dis[i][j] = val[i][j]; // 初始化最短路矩阵
int ans = inf;
for (int k = 1; k <= n; ++k) {
for (int i = 1; i < k; ++i)
for (int j = 1; j < i; ++j)
ans = std::min(ans, dis[i][j] + val[i][k] + val[k][j]); // 更新答案
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = std::min(
dis[i][j], dis[i][k] + dis[k][j]); // 正常的 floyd 更新最短路矩阵
}
return ans;
}
22.dijkstra
单调队列优化1
#include单调队列优化2
#include23.SPFA
#includedfs判负环
#includebfs1
#include