小翔和小明正在挑战一个神奇的迷宫。迷宫由n个房间组成，每个房间的编号为1~n，其中1号房间是他们俩初始位置，
所有房间一共由n-1条路连接，使得房间两两之间能够相互达到（构成一棵树），每条路的长度为Wi。
  每当小翔和小明都在房间时，他们的神奇手机就能显示两人的位置（两人分别在哪两个房间），现在想请聪明的ACMer
快速地算出他们之间的最短距离。

  第一行输入整数n（0<n<=100000），表示迷宫有n个房间。
  接下来n-1行，每行输入3个整数u,v,w（1<=u,v<=n,u!=v,w<=10000），表示编号为u和v的房间之间有一条长为w的路。
  第n+1行输入整数m（0<m<=100000），表示有m次询问。
  接来下m行，每行输入2个整数u,v（1<=u,v<=n），表示小翔和小明当前所在房间的编号。

对于每次询问的输出占一行，输出一个整数d表示小翔和小明之间的最短距离。

4

1 2 1

2 3 1

1 4 1

1

3 4

3

这是CSUST选拔赛的一题,表示当时不会LCA  菜的抠脚 （菜是原罪啊） 
注意这题时间为1S N为1e6  最短路肯定是不行的，复杂度不行。
n个点n-1条路 保证联通 其实就是每一个点到另外一个点有唯一的路径。
然后这就是一个非常非常裸的LCA。

 #include<stdio.h>

 #include<string.h>

 #include<algorithm>

 #include<queue>

 #include<vector>

 using namespace std;

 #define maxn 100010

 struct node {

     int x,y;

     node(int x=,int y=):x(x),y(y){};

 };

 int rk[maxn],d[maxn],p[maxn][];

 vector<node>a[maxn];

 int n;

 void dfs(int u,int fa,int cnt) {

     rk[u]=cnt;

     p[u][]=fa;

     int len=a[u].size();

     for (int i= ; i<len ; i++) {

         int x=a[u][i].x;

         if (x!=fa) {

             d[x]=d[u]+a[u][i].y;

             dfs(x,u,cnt+);

         }

     }

 }

 void lca() {

     for (int i= ; i<=n ; i++ ) {

         for (int j= ; (<<j)<=n ; j++) {

             p[i][j]=-;

         }

     }

     for (int j= ; (<<j)<=n ; j++) {

         for (int i= ; i<=n ; i++) {

             if (p[i][j-]!=-) p[i][j]=p[p[i][j-]][j-];

         }

     }

 }

 int query(int x,int y) {

     if (rk[x]<rk[y]) swap(x,y );

     int k;

     for (k= ; (<<(+k))<=rk[x] ; k++);

     for (int i= k; i>= ; i--) {

         if (rk[x]-(<<i)>=rk[y]) x=p[x][i];

     }

     if (x==y) return x;

     for (int i= k; i>= ; i--) {

         if (p[x][i]!=- && p[x][i]!=p[y][i]){

             x=p[x][i];

             y=p[y][i];

         }

     }

     return p[x][];

 }

 int  main() {

     int q,u,v,w;

     while(scanf("%d", &n)!=EOF) {

         for (int i = ; i < n; i++) {

             scanf("%d%d%d", &u, &v, &w);

             a[u].push_back(node(v, w));

             a[v].push_back(node(u, w));

         }

         dfs(, -, );

         lca();

         scanf("%d", &q);

         while (q--) {

             scanf("%d%d", &u, &v);

             printf("%d\n", d[u]+d[v]-*d[query(u, v)]);

         }

     }

     return ;

 }

其中DFS（int u,int fa, int cnt)
u表示当前节点 fa为他的父亲节点 cnt代表的是深度；
int rk[maxn]记录深度  d[maxn] 记录节点  p[maxn][30]记录父亲节点的位置
 lca() 这个就是精髓所在了 第一步初始化p[i][j]=-1；
第二步就是二进制优化了 p[i][j]=p[p[i][j-1]][j-1]  表示i+2^j=i+2^(j-1)+2^(j-1)

前面都是预处理 第三步query（int x,int y) 求x，y的公共祖先。
先判断深度，然后算出2^k <rk[x] 的k的最大值。
if (rk[x]-(1<<i)>=rk[y]) x=p[x][i];将x的的深度向上回溯2^i 
使之更接近rk[y]

以上就是我对LCA倍增算法的解析  
如果读者还有不懂可以留言给我。