倍增
定义
倍增是一种与二分相似的算法，但是把二进制摆在了明面上。
大体思路是一步步确定答案的二进制表示的每一位。
简单倍增
例题：洛谷 P2249 【深基13.例1】查找
你说得对，但是这题其实是二分模板题。
首先转化为找到第一个小于 \(q\) 的位置 \(p\)。
因为长度不大于 \(10^6\)，所以答案一定可以用一个二十位二进制数来表示，因为 \(2^{20}>10^6\)
然后我们就尝试从高到低确定这个答案的每一位。
显然对于从低到高第 \(i\) 位，数值是 \(2^{i}\)，其中 \(i\ge 0\)。
那么我们判断，如果 \(2^i\le n\land a_{p_{i}}<q\)，那么说明答案的第 \(i\) 位一定是一。
因为如果这一位不是一，那么就算后面所有的二进制位都是 \(1\)，总和也没有 \(2^{i}\) 大，是更到不了 \(a_{ans}\) 的。
如果 \(a_{p_i}\ge q\)，说明跳太大了，这一位是 \(0\)。
简言之，二分是通过检查 mid 的可行性，而倍增是通过 check 每个二进制位的可行性。
以此类推，直到找到答案为止。
最后要记得特判是否越界。
代码：
#include<bits/stdc++.h>
using namespace std;
typedef long long ljl;
#define FUP(i,x,y) for(int i=(x);i<=(y);++i)
#define FDW(i,x,y) for(int i=(x);i>=(y);--i)
const int N=1e6+5;
int n,q,a[N],x;void Main()
{int p=0;cin>>x;FDW(i,20,0){if((p|(1<<i))<=n&&a[p|(1<<i)]<x)p=p|(1<<i);}if(p<n&&a[p+1]==x)cout<<p+1<<' ';else cout<<"-1 ";return;
}
int main(){ios::sync_with_stdio(0);cin>>n>>q;FUP(i,1,n)cin>>a[i];while(q--)Main();cout<<'\n'; return 0;
}对于倍增的感性理解
首先我们知道，对于任意一个整数都可以分解成二进制的形式。
那么假设我们开了挂，知道了答案，那么这个答案 \(ans\) 也是由一位位的二进制数表达的。
那么我们就可以尝试跳步子。
第一次跳足够长，如果超出了，就撤回这一步，尝试更小的步子。
如果没超过，就迈出去。
这样迈出去对应 \(1\)，撤回对应 \(0\)，总可以凑成 \(ans\)。
树上倍增
因为倍增的结构相对稳定，那么就可以在多个数据结构上使用，就比如树。
举个例子，LCA！
Luogu P3379 【模板】最近公共祖先（LCA）
那么在树上，我们该怎么维护呢？
首先二分显然不太好搞。因为无法快速求出两点之间的中点。
我们考虑递推。
设 \(f_{i,j}\) 表示从 \(i\) 出发，跳了 \(2^j\) 步所到达的点。
那么显然有 \(f_{i,j}=f_{f_{i,j-1},j-1}\)，即在 \(i\) 上先跳 \(2^{j-1}\) 步，再跳 \(2^{j-1}\) 步的结果。
因为 \(2^j=2^{j-1}+2^{j-1}\)。
代码：
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+5,M=N;
int n,q,s,cnt_e,ehead[N],fa[N][25],dep[N];
struct E{int to,pre;
}e[M<<1];
void adde(int from,int to)
{e[++cnt_e].to=to;e[cnt_e].pre=ehead[from];ehead[from]=cnt_e;return;
}
void dfs(int u,int uf)
{fa[u][0]=uf;dep[u]=dep[uf]+1;for(int i=1;i<=20;++i)fa[u][i]=fa[fa[u][i-1]][i-1];for(int i=ehead[u];i;i=e[i].pre){int v=e[i].to;if(v==uf)continue;dfs(v,u);}return;
}
int getlca(int x,int y)
{if(x==y)return x;if(dep[x]<dep[y])swap(x,y);for(int i=20;i>=0;--i)if(dep[x]-(1<<i)>=dep[y])x=fa[x][i];if(x==y)return x;for(int i=20;i>=0;--i){if(fa[x][i]!=0&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];}return fa[x][0];
}
int main(){
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>q>>s;for(int i=1,u,v;i<n;++i){cin>>u>>v;adde(u,v);adde(v,u);}dfs(s,0);while(q--){int u,v;cin>>u>>v;cout<<getlca(u,v)<<'\n';}return 0;
}
同理，树上倍增不仅可以维护祖先，还可以顺便维护一些链信息。
比如用 \(m_{i,j}\) 表示从 \(i\) 出发，跳 \(2^j\) 步的过程中，所有节点的权值最大值。
那么状态转移方程也大差不差：\(m_{i,j}=\max\left\{m_{i,j-1},m_{f_{i,{j-1}},j-1}\right\}\)
未知上界
如题，就是一种上界未知的二分。
其实说是未知，但毕竟是有答案的，所以上界也是有的。
现在讨论的是如何快速确定上界，即算法本身不依赖于上界，时间复杂度为 \(\log ans\)。
还是用二进制玩。
我们从小到大枚举 \(i\)，check 一下 \(2^i\) 可不可行。如果没跳过就跳。
如果跳过了，假设 \(2^t\) 时超过答案。
那么答案就被确定在了 \([2^{t-1},2^t)\)，然后再从 \(t-1\) 至 \(0\) 枚举 \(j\)，按照之前说的倍增方法一步一步确定答案即可。
总结：先逐渐扩大步长，够用了后再一步步缩短步长。也就是只有锁定第一步时是从小到大，其他都是从大到小。
优势：不依赖总大小，只依赖于答案。
