8.17-8.18 倍增算法及其经典应用:RMQ+ST表、树上倍增求LCA

joenfoc

已于 2022-08-18 17:42:49 修改

阅读量304

点赞数

分类专栏：算法打卡学习文章标签：算法 c++

于 2022-08-17 22:19:16 首次发布

本文链接：https://blog.csdn.net/m0_62709362/article/details/126375070

版权

算法打卡学习专栏收录该内容

20 篇文章 1 订阅

订阅专栏

一、倍增算法介绍

倍增法（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)=max(f(i,j-1),f(i+2^{j-1},j-1)) , \$
$其中，f(i,j-1)表示区间[i,i+2^{j-1}-1] 的最大值， \$
$f(i+2^{j-1},j-1))表示区间[i+2^{j-1},i+2^{j-1}+2^{j-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代表某点到树根的距离

链接: HDU2586 How far away ？

树上倍增：
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;
	}
}