zoj 3195(LCA加强版)

传送门:Problem 3195

https://www.cnblogs.com/violet-acmer/p/9686774.html

题意：

　　给一个无根树，有q个询问，每个询问3个点(a,b,c)，问将这3个点连起来，距离最短是多少。

题解：

　　我的思路：

　　　　(1)分别求出Lca(a,b),Lca(a,c),Lca(b,c);

　　　　(2)找到三个Lca( )中深度最深的那个节点（此处假设Lca(a,b)深度最深），设变量 res = dist[a]+dist[b]-2*dist[Lca(a,b)];

　　　　(3)求出Lca(a,b)与c的最近公共祖先，res += dist[c]+dist[Lca(a,b)]-2*dist[Lca(a,b,c)];

　　参考大佬题解思路：

　　　　分别求LCA(a,b),LCA(a,c),LCA(b,c)，和对应的距离，然后3个距离相加再除以2就是这个询问的结果。

AC代码：

　　晚上看了LCA的RMQ算法的一个题，改了一晚上，貌似理解了，太累了，明天再把这个代码的细节写一下.............

 #include<iostream>
 #include<cstdio>
 #include<vector>
 #include<cstring>
 using namespace std;
 #define pb push_back
 #define ll long long
 #define mem(a,b) (memset(a,b,sizeof a))
 const int maxn=5e4+;

 struct Node
 {
     int to;
     int weight;
     Node(int to,int weight):to(to),weight(weight){}
 };
 vector<Node >edge[maxn];
 int n,q;
 int fa[][maxn];
 int dist[maxn];
 int depth[maxn];
 void addEdge(int u,int v,int w)
 {
     edge[u].pb(Node(v,w));
     edge[v].pb(Node(u,w));
 }
 void Init()
 {
     for(int i=;i < n;++i)
         edge[i].clear();
 }
 void Dfs(int u,int f,int d,int l)
 {
     fa[][u]=f;
     dist[u]=l;
     depth[u]=d;
     for(int i=;i < edge[u].size();++i)
     {
         int to=edge[u][i].to;
         int w=edge[u][i].weight;
         if(to != f)
             Dfs(to,u,d+,l+w);
     }
 }
 void Pretreat()
 {
     Dfs(,-,,);
     for(int k=;k+ < ;++k)
         for(int u=;u < n;++u)
             if(fa[k][u] == -)
                 fa[k+][u]=-;
             else
                 fa[k+][u]=fa[k][fa[k][u]];
 }
 int Lca(int u,int v)
 {
     if(depth[u] > depth[v])
         swap(u,v);
     int k;
     for(k=;(<<k) <= depth[v];++k);
     k--;
     for(int i=k;i >= ;--i)
         if((depth[v]-(<<i)) >= depth[u])
             v=fa[i][v];
     if(u == v)
         return v;
     for(int i=k;i >= ;--i)
         if(fa[i][v] != - && fa[i][v] != fa[i][u])
         {
             v=fa[i][v];
             u=fa[i][u];
         }
     return fa[][v];
 }
 int main()
 {
     bool flag=false;
     while(~scanf("%d",&n))
     {
         Init();
         if(flag)
             printf("\n");
         flag=true;
         for(int i=;i < n;++i)
         {
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             addEdge(u,v,w);
         }
         Pretreat();
         scanf("%d",&q);
         for(int i=;i <= q;++i)
         {
             int a,b,c;
             scanf("%d%d%d",&a,&b,&c);
             int res;
             int lcaAB=Lca(a,b);
             int lcaAC=Lca(a,c);
             int lcaBC=Lca(b,c);
             if(depth[lcaAB] > depth[min(lcaAC,lcaBC)])
             {
                 res=dist[a]-dist[lcaAB]+dist[b]-dist[lcaAB];
                 res += dist[lcaAB]-dist[Lca(lcaAB,c)]+dist[c]-dist[Lca(lcaAB,c)];
             }
             else if(depth[lcaAC] > depth[min(lcaAB,lcaBC)])
             {
                 res=dist[a]-dist[lcaAC]+dist[c]-dist[lcaAC];
                 res += dist[lcaAC]-dist[Lca(lcaAC,b)]+dist[b]-dist[Lca(lcaAC,b)];
             }
             else
             {
                 res=dist[b]-dist[lcaBC]+dist[c]-dist[lcaBC];
                 res += dist[lcaBC]-dist[Lca(lcaBC,a)]+dist[a]-dist[Lca(lcaBC,a)];
             }
             printf("%d\n",res);
         }
     }
     return ;
 }

基于二分的LCA