http://acm.hdu.edu.cn/showproblem.php?pid=2586
忽然发现访客量有点多。在贴一个树剖LCA的板子吧。
最近做树形DP和树形结构时,发现LCA这个东西有点家常,而以前也只会离线算法,现在补一下这个知识点,在这里丢两个模板。
在线倍增算法,感觉也不是很难,当你真正的了解了倍增的意思,这个算法真的就不难了。
首先 p[i][j]表示i结点的第2^j个父亲结点,初始化也很简单, p[i][j]=p[p[i][j-1]][j-1],这个理解了,这个算法理解了一半;
他的父亲结点是排在一条链上,所以这不就是把这个链分成两部分。
我们在寻找LCA时,首先要建图,同时还要保存结点的直接父亲信息,和距离,以及深度等
用DFS就可以了。
然后就是LCA了,这个首先比较x和y的深度,较深的先开始回溯,当同一深度就一起回溯,就完了;网上也有很多博客讲得很好
可以参考一下。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node{
int v,w;
};
const int N=400010;
vector<node>g[N];
int fa[N],dis[N],dep[N],n,m;
void dfs(int u,int f,int deep)
{
fa[u]=f,dep[u]=deep;
for(int i=0;i<g[u].size();i++){
int v=g[u][i].v;
if(v==f) continue;
dis[v]=dis[u]+g[u][i].w;
dfs(v,u,deep+1);
}
}
int p[N][30];
void init_lca()
{
for(int j=0;(1<<j)<=n;j++)
for(int i=1;i<=n;i++)
p[i][j]=-1;
for(int i=1;i<=n;i++) p[i][0]=fa[i];
for(int j=1;(1<<j)<=n;j++)
for(int i=1;i<=n;i++)
{
if(p[i][j-1]!=-1)
p[i][j]=p[p[i][j-1]][j-1];
}
}
int LCA(int x,int y)
{
if(dep[x]<dep[y]) swap(x,y);
int lg=0;
while((1<<lg)<=dep[x])lg++;
lg--;
for(int i=lg;i>=0;i--){
if(dep[x]-(1<<i)>=dep[y])
x=p[x][i];
}
if(x==y) return x;
for(int i=lg;i>=0;i--){
if(p[x][i]!=-1&&p[x][i]!=p[y][i])
x=p[x][i],y=p[y][i];
}
return fa[x];
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;cin>>T;
while(T--){
cin>>n>>m;
for(int i=1;i<=n;i++) g[i].clear();
for(int i=1;i<n;i++){
int u,v,w;
cin>>u>>v>>w;
g[u].push_back(node{v,w});
g[v].push_back(node{u,w});
}
dis[1]=0;
dfs(1,-1,0);
init_lca();
while(m--){
int u,v;
cin>>u>>v;
printf("%d\n",dis[u]+dis[v]-2*dis[LCA(u,v)]);
}
}
return 0;
}
树剖LCA稍微比倍增快一点。
struct edge {
int v, next;
} ed[maxn << 1];
int head[maxn], cnt, top[maxn], son[maxn], dep[maxn], f[maxn], sz[maxn];
void add_edge(int u, int v) {
++cnt;
ed[cnt].v = v;
ed[cnt].next = head[u];
head[u] = cnt;
}
void dfs1(int u, int fa, int d) {
sz[u] = 1, f[u] = fa, dep[u] = d;
for (int i = head[u]; i; i = ed[i].next) {
int v = ed[i].v;
if (v == fa) continue;
dfs1(v, u, d + 1);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int t) {
top[u] = t;
if (!son[u]) return;
dfs2(son[u], t);
for (int i = head[u]; i; i = ed[i].next) {
int v = ed[i].v;
if (v != f[u] && v != son[u]) dfs2(v, v);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]])
swap(x, y);
x = f[top[x]];
}
if (dep[x] > dep[y]) return y;
return x;
}
离线算法 是用 tarjan和并查集实现的,总的来说,不难理解,网上很多博客对这个算法写的很好,自己拿这笔跟着博客的思路画一遍就理解了。
///#include <bits/stdc++.h>
#include<stdio.h>
#include<queue>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<vector>
#include<set>
#include<stack>
using namespace std;
const int N=400010;
int n,m,inp[N];
struct node
{
int u,v,len,next,dis;
}ed[N],ed1[N];
int fa[N],vis[N],dis[N];
int head[N],head1[N],cnt,cnt1;
void init(int n)
{
memset(vis,0,sizeof(vis));
memset(dis,0,sizeof(dis));
memset(head1,-1,sizeof(head1));
memset(head,-1,sizeof(head));
cnt1=cnt=0;
for(int i=0;i<=n;i++)
{
fa[i]=i;
}
}
void add(int u,int v,int w)
{
ed[cnt].u=u,ed[cnt].v=v;
ed[cnt].len=w;
ed[cnt].next=head[u];
head[u]=cnt++;
}
void add1(int u,int v)
{
ed1[cnt1].u=u,ed1[cnt1].v=v;
ed1[cnt1].next=head1[u];
head1[u]=cnt1++;
}
int ffind(int x)
{
if(fa[x]==x)
return x;
return fa[x]=ffind(fa[x]);
}
void unite(int x,int y)
{
int fx=ffind(x);
int fy=ffind(y);
if(fx!=fy)
fa[fy]=fa[fx];
}
void tarjan(int u)
{
vis[u]=1;
for(int i=head[u];i!=-1;i=ed[i].next)
{
int v=ed[i].v;
int w=ed[i].len;
if(vis[v])
continue;
dis[v]=dis[u]+w;
tarjan(v);
unite(u,v);
}
for(int i=head1[u];i!=-1;i=ed1[i].next)
{
int v=ed1[i].v;
if(vis[v])
{
ed1[i].dis=ed1[i^1].dis=ffind(v);
}
}
}
int main()
{
int T;scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
int u,v,len;
init(n);
for(int i=1;i<n;i++)
{
scanf("%d%d%d",&u,&v,&len);
add(u,v,len);
add(v,u,len);
}
for(int i=1;i<=m;i++)
{
scanf("%d%d",&u,&v);
add1(u,v);
add1(v,u);
}
dis[1]=0;
tarjan(1);
for(int i=0;i<m;i++)
{
int u=ed1[2*i].u,v=ed1[2*i].v,lca=ed1[2*i].dis;
printf("%d\n",dis[u]+dis[v]-2*dis[lca]);
}
}
return 0;
}
//