HDU-2586 How far away？ LCA模板题 倍增 邻接表/head

题目链接：HDU-2586

求树上两点距离最短，即ans=两点深度和-LCA最近公共祖先深度*2

模板1 邻接表存图

#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define endl  '\n'
#define inf 0x3f3f3f3f
using namespace std;
const int mod=1e9+7;
const int MAX=50007;
using namespace std;
vector<int>v[MAX],w[MAX];

int fa[MAX][31], cost[MAX][31], dep[MAX];
int n, m , N; //点数，边数 ,最多跳的次数 
int a, b, c;
void dfs(int root, int fno) {
  fa[root][0] = fno;
  dep[root] = dep[fa[root][0]] + 1;
  for (int i = 1; i < 31; ++i) {    //自下而上，fa[root][i]表示root的第2^i个祖先 
    fa[root][i] = fa[fa[root][i - 1]][i - 1];
    cost[root][i] = cost[fa[root][i - 1]][i - 1] + cost[root][i - 1];
  }
  int sz = v[root].size();//当前根的节点数 
  for (int i = 0; i < sz; ++i) {
    if (v[root][i] == fno) continue;
    cost[v[root][i]][0] = w[root][i];
    dfs(v[root][i], root);  //换根再次进行dfs 
  }
}
int lca(int x, int y) {
  if (dep[x] > dep[y]) swap(x, y);
  int tmp = dep[y] - dep[x], ans = 0;
  for (int j = 0; tmp; ++j, tmp >>= 1)   //先向上调整深度较大的点，令他们深度相同
    if (tmp & 1) ans += cost[y][j], y = fa[y][j];
  if (y == x) return ans; //深度相同时是同个点 
  for (int j = 30; j >= 0 && y != x; --j) {  //深度相同,共同向上跳转，直到相遇 
    if (fa[x][j] != fa[y][j]) {
      ans += cost[x][j] + cost[y][j];
      x = fa[x][j];
      y = fa[y][j];
    }
  }
  ans += cost[x][0] + cost[y][0];
  return ans;
}
int main() {
	ios_base::sync_with_stdio(0);cin.tie(0),cout.tie(0);
	int t;cin>>t;
	while(t--){
		memset(fa,0,sizeof(fa));
		memset(cost,0,sizeof(cost));
		memset(dep,0,sizeof(dep));
	  	cin>>n>>m;
	  	//N = floor(log(n + 0.0) / log(2.0));
	  	for(int i=0;i<=n+1;i++)v[i].clear(),w[i].clear();
		for(int i=1;i<=n-1;i++){
	   		cin>>a>>b>>c; a; b;
		    v[a].push_back(b); v[b].push_back(a);
		    w[a].push_back(c); w[b].push_back(c);
		}
		dfs(1,0);
	  	for (int i=0;i<m;i++) {
	    	cin>>a>>b; a,b;
	    	cout<<lca(a,b)<<endl;
	  	}
	}
	
  return 0;
}

模板2 head链式前向星存图

#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define endl  '\n'
#define inf 0x3f3f3f3f
#define MAX 50007
using namespace std;
struct Edge 
{
    int nxt,to,w;
}edge[MAX*2+5];

int n,m; // 点数、边数 
int root,cnt; 
int head[MAX+5],dep[MAX+5],dis[MAX+5]; //头，深度，距离权值 
int f[MAX+5][35];//存f[x][i]，x的2^i个祖先 
int vis[MAX+5];

void add(int u,int v,int w)
{
    edge[++cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
}
void dfs(int u,int fa)
{
    dep[u]=dep[fa]+1;
    for(int i=0; i<=31; i++)   //自下而上，f[u][i]表示u的第2^i个祖先
        f[u][i+1]=f[f[u][i]][i];

    for(int i=head[u]; i; i=edge[i].nxt){
        if(edge[i].to==fa)continue;
        f[edge[i].to][0]=u;
        dis[edge[i].to]=dis[u]+edge[i].w;
        dfs(edge[i].to,u);   //换根再次进行dfs 
    }
}
int LCA(int x,int y)
{
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=31; i>=0; i--){      //先向上调整深度较大的点，令他们深度相同
    	if(dep[f[x][i]]>=dep[y])
            x=f[x][i];
        if(x==y) return x;//深度相同时,特判是否是同个点
 	}
    for(int i=31; i>=0&&x!=y; i--)
        if(f[x][i]!=f[y][i]){  //深度相同,共同向上跳转，直到相遇 
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];   //返回最近公共祖先的下标 
}

int main()
{
	ios_base::sync_with_stdio(0);cin.tie(0),cout.tie(0);
    int t;cin>>t;
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        memset(edge,0,sizeof(edge));
        memset(f,0,sizeof(f));
        memset(dep,0,sizeof(dep));
        memset(head,0,sizeof(head));
        memset(dis,0,sizeof(dis));
        cnt=0;
        cin>>n>>m;
        for(int i=1; i<=n-1; i++){
            int u,v,w;cin>>u>>v>>w;
            add(u,v,w); add(v,u,w);
            vis[v]=1;
        }
        root=1;
		//while(vis[root]!=0)root++; 
        dfs(root,0);
        for(int i=1; i<=m; i++){
            int a,b;cin>>a>>b;
            cout<<dis[a]+dis[b]-2*dis[LCA(a,b)]<<endl;
        }
    }
    return 0;
}