数据结构
二叉搜索树
递归定义
它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。
•维护一个集合，支持操作：插入、删除、查找
•方法：建立一棵有序的二叉树，每个结点对应集合中一个元素。
•满足性质：结点u的左子树的结点权值都比u小，右子树的结点权值都比u大。
•插入、删除、查找只需在二叉树中按照权值往下走即可。
可能的问题：
可能退化成一条链（例如如果按升序插入），那么每次操作平均复杂度O(n)需要一些技巧让二叉搜索树保持平衡。STL中的set和map都是平衡的二叉搜索树。noip一般情况下够用。
线段树
护区间信息的数据结构
每个结点对应一个序列的区间
完全二叉树，左子树为左一半区间，右子树为右一半
单点/区间修改。
动态开点
例题
维护一个数据结构，支持以下两种操作：
1.插入一个数x
2.查询[l,r]区间中有多少个数
操作数<=10^5 x,l,r<=10^9
强制在线
用线段树做
做法
注意虽然inf=10^9很大，log(inf)还是很小
操作数很少
每个结点的值表示对应区间内的数的个数
每次操作至多增加\(O(logn)\)个非零结点
我们只需要将这\(logn\)个非零结点开出来即可，空间复杂度\(O(nlog(inf))\)
查询时，如果碰到没有开出的结点，说明这个结点值为\(0\)，返回\(0\)即可
注意此时不能使用数组模拟二叉树的方法（和堆类似，\(1\)为根，\(2n-1\)和\(2n\)分别为n的左右儿子） 因为得开\(10^9\)的数组，爆空间
得加上左右儿子指针的数组。
为新开的结点赋予大于零的编号 \(o=++tot\);
查询时遇到结点编号为\(0\)，就说明这个结点为空，对应区间中没有数
线段树的合并
考虑都是动态开点的两棵权值线段树（结点权值为对应区间的数的个数），如何将这两棵线段树合并？（即将他们对应的两个数集合并）
tree *merge(int l, int r, tree *A, tree *B){
if(A == NULL) return B;
if(B == NULL) return A;
if(l == r) return new tree(NULL, NULL, A -> data + B ->data);
int mid = (l + r) >> 1;
return new tree(merge(l, mid, A -> ls, B -> ls), merge(mid + 1, r, A -> rs, B -> rs), A -> data + B -> data);
}
复杂度：两棵线段树中重合结点（对应位置都开出来的结点）的个数。
一棵权值线段树表示一个数集。
如果每棵权值线段树对应的数集都只有一个数，那么这棵权值线段树只有\(O(log(inf))\)个开出的结点
\(n\)个这样的权值线段树合并，复杂度？
将n个这样表示单元素集合的权值线段树合并，复杂度不会高于将n个元素插入权值线段树。
因此复杂度\(O(nlog(inf))\)
线段树优化建图
以如下方式给定一个有向图：
给出结点量n与参数m
接下来m行，每行三个整数\(l_i,r_i,w_i\)
表示点xi向\([l_i,r_i]\)的每个点连出一条长度为\(w_i\)的边
求1到n点的最短路
\(n,m<=10^5\)
做法
对n个顶点建立一棵线段树。
对于\(l_i,r_i,w_i\)
只需将\([l_i,r_i]\)分解成线段树上\(log(n)\)个结点
\(x_i\)分别向这\(log(n)\)个结点连一条长度为\(w_i\)的有向边即可
边数降为\(O(mlogn)\)
例题
感觉线段树的这些操作听得一脸懵逼
并查集
按秩合并
记录出\(size[i]\)表示这个集合的元素个数，合并时把元素个数小的合并到大的上
为什么要按秩合并？
众所周知，并查集如果深度过深了，会导致查询时复杂度退化所以就可以通过记录\(size\)来减少深度
void join(int x,int y)
{
x=find(x),y=find(y);
if(size[x]<size[y]) f[x]=y,xize[y]+=size[x];
else f[y]=x,xize[x]+=size[y]
}
二分图判定
黑白染色法
大致思路就是先找到一个没被染色的节点u，把它染上一种颜色，之后遍历所有与它相连的节点v，如果节点v已被染色并且颜色和节点u一样，那么就失败了。如果这个节点v没有被染色，先把它染成与节点u不同颜色的颜色，然后遍历所有与节点v相连的节点............就这样循环下去，直到结束为止。
vector<int> q[N];
int col[N];//col[u]表示u的颜色,1为白色,-1为黑色,0为未染色
bool flag=true;
void dfs(int u,int c)
{
col[u]=c;
for(int i=0;i<e[u].size();++i)
{
int v=e[u][i];
if(!col[v]) dfs(v,-c);
else if(col[v]==c) flag=false;
}
}
for(int i=1;i<=n;++i)
if(!col[i]) dfs(i,1);
字典树
之前写的笔记链接
长成这个样子
设字母集为\(\sum\)，则每个结点有至多\(|\sum|\)个儿子
例：给定\(n\)个字符串的集合，\(q\)个询问，每个询问给出一个字符串，询问集合中有没有这个字符串
用\(trie\)做，设字符串总长度为L，空间复杂度\(O(L*|\sum|)\)，时间复杂度\(O(L)\)
int rt=1,cnt=1;
int ch[N][27],sizes[N];//N是最长串
void ins(string s)
{
int o=rt;
for(int i=0;i<s.size();++i)
{
k=s[i]-'a';
if(ch[o][k]) o=ch[o][k];
else ch[o][k]=++cnt,o=ch[o][k];
}
sizes[o]++;
}
int query(string s)//查询有没有出现过
{
int o=rt;
for(int i=0;i<s.size();++i)
{
int k=s[i]-'a';
if(ch[o][k]) o=ch[o][k];
else return 0;
}
return 1;
}
用字典树解决异或问题（01Trie）
给定n个正整数，求这\(n\)个整数中两两异或的最大值？
\(n<=10^5\),每个整数\(a_i<=10^9\)
把每个正整数转换为一个\(30\)位的二进制串，分别插入一棵\(trie\)中
对于每一个整数X，我们想找到它与其它整数异或得到的最大值
沿着\(trie\)从上往下走，采取贪心策略。
每一步设X的当前位为\(b\)，则优先往\(b^1\)方向走（这样可以在结果的这一位得到一个1）；如果\(b^1\)方向没有儿子，则往\(b\)方向走
int ch[N*30][2];
int rt=1,cnt=1;
void ins(int x)
{
int o=rt;
for(int i=30;i>=0;--i)
{
int k=x>>i&1;
if(ch[o][k]) o=ch[o][k];
else ch[o][k]=++cnt,o=cnt;
}
}
int query(int x)
{
int ans=0;
int o=rt;
for(int i=30;i>=0;--i)
{
int k=x>>i & 1;
if(ch[o][k^1]) ans|=1<<i,o=ch[o][k^1];
else o=ch[o][k];
}
return ans;
}
int a[N],n;
for(int i=0;i<n;++i) scanf("%d",a+i);
for(int i=0;i<n;++i) ins(a[i]);
int ans=0;
for(int i=0;i<n;++i) ans=max(ans,query(a[i]));
字符串hash
string s;
usigned long long v=0;//v是s的hash值
usigned long long p=1;
for(int i=0;i<s.size();++i)
{
v+=p*(s[i]-'a');
p*=26ull;
}
双hash
取两个模数之后两个模数的hash都出现过才行
进制hash
把每位看成进制，有效避免了\(ab,ba\)判断不出来的情况
如何得到一个字符串所有子串的hash
给定一个字符串，每次询问给定四个数\(l_1,r_1,l_2,r_2\),满足\(r_1-l_1=r_2-l_2\)问
st表
令\(f[i][j]\)表示从i开始，\(2^j\)个数的最小值
\(f[i][j]\)总共有\(nlogn\)个状态
可以由\(j\)从小到大递推求出
\(f[i][j]=min(f[i][j-1],f[i+(1<<(j-1))][j-1]);\)
感觉这东西和倍增差不多
int a[N],f[N][20];
int lg[N];
void init()
{
for(int i=1;i<=n;++i) f[i][0]=a[i];
for(int j=1;(1<<j)<=n;++j)
for(int i=1;i+(1<<j)-1<=n;++i)
f[i][j]=min(f[i][j-1],f[i+(1<<j)][j-1]);
for(int j=1;(1<<j)<=n;++j) lg[(1<<j)]=j;
for(int j=1;j<=n;+j)
if(!lg[j]) lg[j]=lg[j-1];
}
int query(int l,int r)
{
int k=lg[r-l+1];
return min(f[l][k],f[l-(1<<k)+1][k]);
}
倍增
\(f[i][j]\)表示\(i\)的第\(2^i\)祖先
inr lca(int u,int v)
{
if(dep[u]>dep[v]) swap(u,v);
int k=dep[v]-dep[u];
for(int i=0;i<=lg[k];++i)
if(k>>1&1) v=f[i][k];
if(u==v) return u;
for(int i=lg[n];i>-0;--i)
if(f[u][i]!=f[v][i])
u=f[u][i],v=f[v][i];
return f[u][0];
}
lca转换为RMQ问题
感觉比较难
int seq[N<<1],cnt,pos[N]; //dfs序
int f[N<<1][20],dep[N]; //f[i][j]表示dfs序中从i位置开始2^j个结点中 深度最小的结点
void init() {
for(int i=1;i<=cnt;++i) f[i][0]=seq[i];
for(int j=1;j<=LG[cnt];++j)
for(int i=1;i+(1<<j)-1<=cnt;++i)
f[i][j] = dep[f[i][j-1]]<dep[f[i+(1<<j-1)][j-1]]?f[i][j-1]:f[i+(1<<j-1)][j-1];
}
int lca(int u,int v) {
int a=pos[u],b=pos[v];
if(a>b) swap(a,b);
int k=LG[b-a+1];
return dep[f[a][k]]<dep[f[b-(1<<k)+1][k]]?f[a][k]:f[b-(1<<k)+1][k];
}
tarjan算法离线求lca
ector<int> e[N],Q[N],id[N]; //e是边表，Q[i]中保存的是与i点相关的查询
int f[N],n; //f并查集 已初始化
int ans[N];
bool vis[N]; //dfs时是否经过
int find(int x){return x==f[x]?x:f[x]=find(f[x]);}
void ins_query(int u,int v,int o) {
//插入一个编号为o的询问，询问(u,v)两点的lca
Q[u].push_back(v),id[u].push_back(o);
Q[v].push_back(u),id[v].push_back(o);
}
void dfs(int u) {
vis[u]=true;
for(int i=0;i<Q[u].size();++i) {
int v=Q[u][i];
//id[u][i]表示lca查询(u,v)的编号
if(vis[v]) ans[id[u][i]]=find(v);
}
for(int i=0;i<e[u].size();++i) {
int v=e[u][i];
if(vis[v]) continue;
dfs(v);
f[find(v)]=u;
}
}
一个复杂度的证明
\(n+\frac{n}{2}+\frac{n}{3}+\frac{n}{4}+......+\frac{n}{n}=n(1+\frac{1}{2}+\frac{1}{3}+......+\frac{1}{n})=n\times log(n)\)
非旋转treap即可持久treap
那天没事的时候来看看