关于RMQ(ST实现)方面的博文
Tarjan算法，基于并查集和dfs，是离线算法，离线就是将所有查询先存起来，一次性处理
倍增，在线算法
dfs+RMQ，在线算法，在线表示的是每一次查询，都会处理一次
Tarjan 算法：
这篇博文：https://www.cnblogs.com/JVxie/p/4854719.html 讲得特好
例题：POJ - 1330 -----》只查询一对最近公共祖先
题目大意是输入t,有t组数据，每组数据的第一行为n,接下来有n对（a,b）,前n-1对表示边，a是b的父；最后一对是查询a,b的最近公共祖先。
这题由于只有一次查询，因此比较简单，
代码的流程： 先初始化，将每个结点的父亲都赋值为自己，然后读取边，在vector ve[i]中存的就是结点i的儿子结点，vis数组开始的时候是找根节点，把所有的叶子的结点都标记一下，最后遍历找到根结点（然后就清空vis数组，用于在dfs中标记）,然后从根结点开始dfs。vector que是用来存查询最近公共祖先的，双向存储，为了后面更好的查询。主要就是dfs部分，其余的都比较简单，并查集方面的知识等。
重点讲一下dfs函数：
首先将该结点标记（vis[u]=1），然后递归所有子结点，递归完之后，就是对que[u]进行操作，最后是将pre[u]改为fa。而在对que[u]进行操作时，如果该结点u在查询最近公共祖先（u,v）中，那么结点v要么被标记，要么没别标记，如果被标记的话，那么v的祖先就是它俩的最近公共祖先（依据是dfs的递归过程，以及那个pre[u]=fa）。
可以看下面的图，假设查询的是16和7的最近公共祖先，可以发现当dfs走到7时，由于此时16还没有被标记，所以不会find(16)。当到达16时，递归完16的儿子后，然后进行对que[16]的处理，发现vis[7]已被标记，执行ans=find(7)。此时ans就是它俩的最近公共祖先。理由： 可以发现此时7的祖先就是4，同时4也是7和16的最近公共祖先。（为什么会这样呢，可以根据dfs的递归顺序。两个结点u,v的最近公共祖先，当u已经被标记，然后去v这个结点,那么由u到v的过程中，一定会经过他们的最近公共祖先，（如在7到16的过程中，最近公共最先一定会在其中，7->6->4->10->11->16->3->12->16,也就是4，由于pre[u]=fa这句，4的的左子树（6,15,7）的祖先此时就是4，find(7)就得到它俩的最近公共祖先了）与此同时会会将u的祖先更新为这个最近公共祖先，这个因此find(u)就可得到u,v的最近公共祖先。不太理解的话，可以像下面那样再求几个最近公共祖先就了解了。
代码比较简单，看代码：
#include<iostream>
#include<cmath>
#include <cstring>
#include<cstdio>
#include<algorithm>
#include <vector>
using namespace std;
const int N=1e4+5;
vector<int> ve[N];
vector<int> que[N];
int ans, pre[N],vis[N];
int t, n;
int find(int x)
{
return pre[x]==x?x:pre[x]=find(pre[x]);
}
void init()
{
for(int i=1;i<=n;i++)
{
pre[i]=i;
vis[i]=0;
ve[i].clear();
que[i].clear();
}
}
void dfs(int u,int fa)
{
vis[u]=1;
for(int i=0;i<ve[u].size();i++)
{
int v=ve[u][i];
dfs(v,u);
}//节点u所有的子节点都遍历完了
for(int j=0;j<que[u].size();j++)
{
int v=que[u][j];
if(vis[v])
{
ans=find(v);
}
}
pre[u]=fa;//节点u遍历完之后，将其父节点改为fa,初始的时候是它本身
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
init();
int x, y;
for(int i=0;i<n-1;i++)
{
scanf("%d%d",&x,&y);
ve[x].push_back(y);
vis[y]=1;
}
scanf("%d%d",&x,&y);
que[x].push_back(y);
que[y].push_back(x);
for(int i=1;i<=n;i++)
if(!vis[i])
{
memset(vis,0,sizeof(vis));
dfs(i,-1);
break;
}
printf("%d\n",ans);
}
return 0;
}
如果查询多对最近公共祖先 都是一样的，就是先把它们存储起来
POJ - 1986
思路一样，就是要把询问结果存起来
代码：
// #include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
using namespace std;
const int N=4e4+5;
struct Edge{
int to;
int val;
int nxt;
}edge[N<<1];
int head[N];
int cnt=0;
int n, m;
int ans[N];//存结果
void addEdge(int u,int v, int val)
{
edge[cnt].to=v;
edge[cnt].val=val;
edge[cnt].nxt=head[u];
head[u]=cnt++;
}
struct QEdge
{
int to;
int id;
int nxt;
}qEdge[N<<1];
int qhead[N];
int qcnt=0;
int pre[N];
int vis[N];
int dist[N];//各结点到根节点的距离
void addqEdge(int u,int v,int id)
{
qEdge[qcnt].to=v;
qEdge[qcnt].id=id;
qEdge[qcnt].nxt=qhead[u];
qhead[u]=qcnt++;
}
void init(int n)
{
for(int i=1;i<=n;i++)
{
pre[i]=i;
head[i]=qhead[i]=-1;
vis[i]=0;
}
}
int find(int x)
{
return pre[x]==x?x:pre[x]=find(pre[x]);
}
void Tarjan(int u,int fa,int dis)
{
// cout<<"?"<<u<<endl;
vis[u]=1;
dist[u]=dis;
for(int i=head[u];~i;i=edge[i].nxt)
{
int to=edge[i].to;
if(!vis[to])
Tarjan(to,u,dis+edge[i].val);
}
for(int i=qhead[u];~i;i=qEdge[i].nxt)
{
int to=qEdge[i].to;
if(vis[to])
{
ans[qEdge[i].id]=dist[u]+dist[to]-2*dist[find(to)];
}
}
pre[u]=fa;
}
int main()
{
int t;
int x, y , val ;
char c;
// scanf("%d",&t);
// while(t--)
// {
scanf("%d%d",&n,&m);
// cin>>n>>m;
init(n);
cnt=0;
for(int i=0;i<m;i++)
{
scanf("%d %d %d %*c",&x,&y,&val);
// cin>>x>>y>>val>>c;
addEdge(x,y,val);
addEdge(y,x,val);
}
qcnt=0;
int k;
cin>>k;
for(int i=0;i<k;i++)
{
scanf("%d%d",&x,&y);
// cin>>x>>y;
addqEdge(x,y,i);
addqEdge(y,x,i);
}
Tarjan(1,1,0);
for(int i=0;i<k;i++)
{
cout<<ans[i]<<endl;
}
// cout<<endl;
// }
return 0;
}
倍增
例题 ：HDU - 2586
dfs+RMQ
#include<iostream>
#include<cmath>
#include <cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1e5+5;
const int M=20;
struct Edge
{
int to;
int next;
int w;
}edge[maxn];
int head[maxn];
int dir[maxn];
int dep[maxn];
int fa[maxn][M];
int cnt;
void init()//初始化
{
cnt=0;
memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)//链式前向星
{
edge[cnt].to=v;
edge[cnt].w=w;
edge[cnt].next=head[u];//指向下一个以u开头的下标
head[u]=cnt++;//头指向当前位置，存的是edge的下标，即最后一个输入的
}
int n;
void dfs(int u,int dist,int deep,int f)
{
dir[u]=dist;
dep[u]=deep;
fa[u][0]=f;
for(int i=head[u];~i;i=edge[i].next)
{
int v=edge[i].to;
if(v==u||v==f) continue;
dfs(v,dist+edge[i].w,deep+1,u);
}
}
void presolve()//预处理
{
dfs(1,0,0,1);
for(int i=1;i<M;i++)
{
for(int j=1;j<=n;j++)
fa[j][i]=fa[fa[j][i-1]][i-1];
}
}
int lca(int u,int v)
{
while(dep[u]!=dep[v])
{
if(dep[u]<dep[v]) swap(u,v);//使u是更深的那个
int d=dep[u]-dep[v];
for(int i=0;i<M;i++)
{
if((1<<i)&d) u=fa[u][i];//避免与d相等
}
}
if(u==v) return u;
for(int i=M-1;i>=0;i--)
{
if(fa[u][i]!=fa[v][i])
{
u=fa[u][i];
v=fa[v][i];
}
}
return fa[u][0];
}
int query(int u,int v)
{
return dir[u]+dir[v]-2*dir[lca(u,v)];
}
int main()
{
int t;
int m;
scanf("%d",&t);
while(t--)
{
init();
scanf("%d%d",&n,&m);
for(int i=1;i<=n-1;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
//建立双向边
add(u,v,w);
add(v,u,w);
}
presolve();//预处理
while(m--)
{
int u,v;
scanf("%d%d",&u,&v);
printf("%d\n",query(u,v));
}
}
return 0;
}
1121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
