一、倍增算法介绍
倍增法(binary lifting),意思就是翻倍,以2幂的成倍的增长。它能够使线性的处理转化为对数级的处理,大大地优化时间复杂度。倍增算法一般比较稳定,时间 O(logn)
二、倍增经典应用
2.1 RMQ问题–区间最大(最小)值
2.1.1 RMQ+ST表
RMQ ( Range Maximum/Minimum Query ),表示区间最大(最小)值。使用倍增思想解决 RMQ 问题的方法是 ST 表。
ST表基于倍增思想,可以做到 O(n logn)预处理,O(1) 回答每个询问。但是不支持修改操作,所以其时间复杂度为O(n logn)~O(1) 。ST 表是用于解决可重复贡献问题的数据结构,举例:
现有一长度为n的数组,有m次询问,输出每次询问指定区间的最大值。
首先依次枚举区间长度为2的区间,列出如下最大值:
最后枚举区间长度为4的区间的最大值:
按照这个方法依次更新下去,直至更新完毕,区间长度依次为1,2,4,8…
用
函数
f
(
i
,
j
)
表示区间
[
i
,
i
+
2
j
−
1
]
的最大值
函数f(i,j)表示区间[i,i+2^{j}-1] 的最大值 \
函数f(i,j)表示区间[i,i+2j−1]的最大值
更新的方程为
f
(
i
,
j
)
=
m
a
x
(
f
(
i
,
j
−
1
)
,
f
(
i
+
2
j
−
1
,
j
−
1
)
)
,
更新的方程为f(i,j)=max(f(i,j-1),f(i+2^{j-1},j-1)) , \
更新的方程为f(i,j)=max(f(i,j−1),f(i+2j−1,j−1)),
其中,
f
(
i
,
j
−
1
)
表示区间
[
i
,
i
+
2
j
−
1
−
1
]
的最大值,
其中,f(i,j-1)表示区间[i,i+2^{j-1}-1] 的最大值, \
其中,f(i,j−1)表示区间[i,i+2j−1−1]的最大值,
f
(
i
+
2
j
−
1
,
j
−
1
)
)
表示区间
[
i
+
2
j
−
1
,
i
+
2
j
−
1
+
2
j
−
1
−
1
]
的最大值
f(i+2^{j-1},j-1))表示区间[i+2^{j-1},i+2^{j-1}+2^{j-1}-1] 的最大值 \
f(i+2j−1,j−1))表示区间[i+2j−1,i+2j−1+2j−1−1]的最大值
原题链接: P3865 【模板】ST 表
/*倍增+ST表*/
#include<bits/stdc++.h>
using namespace std;
const int logn=21;
const int maxn=100005;
int n,m,a[100005];
int f[maxn][logn+1],Logn[maxn+1];
inline int read()//快读 ,输入输出数据一般很多,建议开启输入输出优化
{
int x=0,f=1;char ch=getchar();
while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
return x*f;
}
void pre(){// 准备工作,初始化
//求log(不用系统的log节省时间)
Logn[1]=0;
Logn[2]=1;
for(int i=3;i<maxn;i++) Logn[i]=Logn[i/2]+1;
}
int main(){
n=read();m=read();
for(int i=1;i<=n;i++) f[i][0]=read();
pre();
for(int j=1;j<=logn;j++){
for(int i=1;i+(1<<j)-1<=n;i++){
f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
}
}
for(int i=1;i<=m;i++){
int l=read(),r=read();
int s=Logn[r-l+1];
//cout<<max(f[l][s],f[r-(1<<s)+1][s])<<endl;
printf("%d\n",max(f[l][s],f[r-(1<<s)+1][s]));//使用cout TLE
}
}
2.1.2 ST 表维护其他信息
除 RMQ 以外,ST 表还可以高效地解决还有其它的“可重复贡献问题”。eg.“区间按位和”、“区间按位或”、“区间 GCD”,。
但是,对于“区间 GCD”,ST 表的查询复杂度并没有比线段树更优(令值域为 w,ST 表的查询复杂度为O(log w) ,而线段树为O(log n+log w) ,且值域一般是大于n 的),但是 ST 表的预处理复杂度也没有比线段树更劣,而编程复杂度方面 ST 表比线段树简单很多。
其实,“可重复贡献问题”一般都带有某种类似 RMQ 的成分。例如“区间按位与”就是每一位取最小值,而“区间 GCD”则是每一个质因数的指数取最小值。
总之,ST 表能较好的维护“可重复贡献”的区间信息,时间复杂度较低,代码量相对其他算法很小。但是,ST 表能维护的信息非常有限,不能较好地扩展,并且不支持修改操作。
2.2 树上倍增求LCA 问题
性质:*d(u,v)=h(u)+h(v)-2h(LCA(u,v))*其中 d是树上两点间的距离, h代表某点到树根的距离
树上倍增:
fa[root][i] = fa[fa[root][i - 1]][i - 1];
第 2^i 的祖先节点是第 2^(i-1) 的祖先节点的第2^(i-1) 的祖先节点。
在求 x,y 两个节点的 LCA 时,如果 x,y 深度不同,则先让深度较大的那个节点向上跳到另一个节点所在的深度。记 dep[u] 表示节点 u 的深度,假设 dep[x]>dep[y] ,那么先让 x 倍增的向上跳 dep[x]−dep[y] 步。
#include<bits/stdc++.h>
#define N 100000+10
using namespace std;
int n,m;
struct node
{
int to,next,cost;
}e[N];
int cnt;
int fa[20][N];
int head[N],depth[N],dis[N];
void init()
{
memset(head,-1,sizeof head);
memset(depth,0,sizeof depth);
memset(dis,0,sizeof dis);
cnt=0;
}
void addedge(int u,int v,int w)//建图过程,建双向边
{
e[cnt].to=v;
e[cnt].cost=w;
e[cnt].next=head[u];
head[u]=cnt++;
}
void DFS(int u,int f)//遍历树
{
fa[0][u]=f;
for(int i=head[u];~i;i=e[i].next)//遍历所有相连的边
{
int To=e[i].to;
if(To!=f)//去掉以后MLE,可能是递归求的过程中太多临时变量
{//建树过程建双向边,会出现to=f的情况,去掉以后会陷入无限递归中
dis[To]=dis[u]+e[i].cost;//更新距离
depth[To]=depth[u]+1;//更新深度
DFS(To,u);
}
}
}
void solve()
{
depth[1]=1;//题目给的是一个树
dis[1]=0;//无论怎么样的树,都可以把1视为根节点
DFS(1,-1);
for(int i=1;i<20;i++)//树上倍增
for(int j=1;j<=n;j++)
fa[i][j]=fa[i-1][fa[i-1][j] ];
}
int LCA(int u,int v)//求最近公共祖先
{
if(depth[u]>depth[v])//保证V的深度比较大
swap(u,v);
for(int i=0;i<20;i++)//倍增到深度相同
if((depth[v]-depth[u])>>i&1)//二进制特性,一定能跳到深度相同
v=fa[i][v];
if(u==v)
return u;
for(int i=19;i>=0;i--)//两者同时倍增
{
if(fa[i][u]!=fa[i][v])
{
u=fa[i][u];
v=fa[i][v];
}
}
return fa[0][v];
}
int main()
{
int i,t;
int a,b,c;
while(scanf("%d",&t)!=EOF)
{
while(t--)
{
init();
scanf("%d%d",&n,&m);
for(i=1;i<n;i++)
{
scanf("%d%d%d",&a,&b,&c);
addedge(a,b,c);
addedge(b,a,c);
}
solve();
for(i=1;i<=m;i++)
{
scanf("%d%d",&a,&b);
int ans=dis[a]+dis[b]-2*dis[LCA(a,b)];
printf("%d\n",ans);
}
}
return 0;
}
}