LCA

倍增算法：

每个数都可以用二进制表示，2^30是一个很大的数，所以可以从二进制的第三十位开始，往后找，可以根据条件找到最大最合适的数。

例题：

C - Closest Common Ancestors

Write a program that takes as input a rooted tree and a list of pairs of vertices. For each pair (u,v) the program determines the closest common ancestor of u and v in the tree. The closest common ancestor of two nodes u and v is the node w that is an ancestor of both u and v and has the greatest depth in the tree. A node can be its own ancestor (for example in Figure 1 the ancestors of node 2 are 2 and 5)
The data set starts with the tree description, in the form:
nr_of_vertices
vertex:(nr_of_successors) successor1 successor2 ... successorn
......
where vertices are represented as integers from 1 to n. The tree description is followed by a list of pairs of vertices, in the form:
nr_of_pairs
(u v) (x y) ...
The input contents several data sets (at least one).
Note that white-spaces (tabs, spaces and line breaks) can be used freely in the input.
For each common ancestor the program prints the ancestor and the number of pair for which it is an ancestor. The results are printed on the standard output on separate lines, in to the ascending order of the vertices, in the format: ancestor:times
For example, for the following tree:

                                                   

the program input and output is:
Input

5
5:(3) 1 4 2
1:(0)
4:(0)
2:(1) 3
3:(0)
6
(1,5) (1,4) (4,2)
(2,3)
(1,3) (4,3)
Output

2:1
5:5

题意：给你一个有根数让你输出他所给的任意两点的最近祖先。输入有毒！！！

解题思路：

套用LCA倍增法模板即可，将所给点的祖先存到一个数组中，然后由小到大逐一输出。

代码:

#include <iostream>
#include <stdio.h>
#include <map>
#include <vector>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll N=1e4+100;
ll bit[30];//存放2^i的数值大小 
vector<int> mp[N];//建图 
ll depth[N];//每个节点距离根节点的深度。 
ll pre[N][30];//存放每个节点的祖先。 
ll print[N];//最后的输出 
void init(int n){//初始化 
    bit[0]=1;
    for(int i=1;i<=29;i++){
        bit[i]=bit[i-1]*2;//求二进制数的十进制大小。 
    }
    for(int i=0;i<=n;i++){
        mp[i].clear();//清空数组 
    }
    memset(depth,0,sizeof(depth));
    memset(pre,0,sizeof(pre));
    memset(print,0,sizeof(print));
}
void dfs(int s,int p){//套用模板 
    pre[s][0]=p;//他的父亲 
    depth[s]=depth[p]+1;//深度是他父亲+1； 
    for(int i=1;i<=29;i++){
        pre[s][i]=pre[pre[s][i-1]][i-1];//2^i=2^(i-1)+2^(i-1) 
    }
    for(int i=0;i<mp[s].size();i++){
        if(mp[s][i]==p) continue;//向下查找 
        dfs(mp[s][i],s);//初始化下一个点 
    }
}

int LCA(int a,int b){
    if(depth[a]<depth[b]){
        swap(a,b);
    }
    int dif=depth[a]-depth[b];//相距深度 
    for(int i=29;i>=0;i--){//先将下边的提到上边使深度相同 
        if(dif>=bit[i]){
            a=pre[a][i];
            dif-=bit[i];
        }
    }
    if(a==b)return a;
    for(int i=29;i>=0;i--){
        if(depth[a]>=bit[i]&&pre[a][i]!=pre[b][i]){//找最上边的一个他们的父亲结点相同但两个节点不同 
            a=pre[a][i];
            b=pre[b][i];
        }
    }
    return pre[a][0];//输出那两个节点的共同父亲结点 
}
int main(){
    int n,a,b,c;
    while(cin>>n){
        map<int,int>mp1;//查询根节点 
        init(n);
        for(int i=1;i<=n;i++){
            scanf("%d:(%d)", &a, &b);
            for(int j=1;j<=b;j++){
                scanf("%d",&c);
                mp1[c]++;//c就不是根节点，标记。 
                mp[a].push_back(c);//存图 
                mp[c].push_back(a);
            }
        }
        for(int i=1;i<=n;i++){
            if(mp1[i]==0){
                dfs(i,0);//找根节点 
                break;
            }
        }
        scanf("%d",&a);
        for(int i=1;i<=a;i++){
            scanf(" (%d,%d)",&b,&c);//输入时左侧可能有空格。 
            print[LCA(b,c)]++;
        }
        for(int i=1;i<=n;i++){
            if(print[i]){
                printf("%d:%d
",i,print[i]);//输出 
            }
        }
    }

    return 0;
}

 

D - How far away ？

 There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this "How far is it if I want to go from house A to house B"? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path("simple" means you can't visit a place twice) between every two houses. Yout task is to answer all these curious people.

Input

First line is a single integer T(T<=10), indicating the number of test cases. 
  For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k(0<k<=40000).The houses are labeled from 1 to n. 
  Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.

Output

For each test case,output m lines. Each line represents the answer of the query. Output a bland line after each test case.

Sample Input

2

3 2

1 2 10

3 1 15

1 2

2 3

 

2 2

1 2 100

1 2

2 1

Sample Output

10

25

100

100

题目大意：

给一个带权有根图，给你任意两个点，你要找出他们两个点相距的距离。

解题思路：

任意找个点为根节点，然后向下寻找，记录每个结点与根结点相距的距离。可以知道，一个点的到根结点的距离是他到他父亲的距离加上他父亲到根结点的距离。最后通过LCA找到最近祖先通过三结点距离根结点的距离算出两点之间的距离。

代码：

#include <iostream>
#include <stdio.h>
#include <map>
#include <vector>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll N=4e4+100;
struct aa{
    int v,d;
};
ll lenth[N];
ll bit[30];
vector<aa> mp[N];
ll depth[N];
int pre[N][30];

void init(int n){
    bit[0]=1;
    for(int i=1;i<=29;i++){
        bit[i]=bit[i-1]*2;
    }
    for(int i=0;i<=n;i++){
        mp[i].clear();
    }
    memset(depth,0,sizeof(depth));
    memset(pre,0,sizeof(pre));
    memset(lenth,0,sizeof(lenth));
}

void dfs(int s,int p){
    pre[s][0]=p;
    depth[s]=depth[p]+1;
    for(int i=1;i<=29;i++){
        pre[s][i]=pre[pre[s][i-1]][i-1];
    }
    for(int i=0;i<mp[s].size();i++){
        if(mp[s][i].v==p) continue;
        lenth[mp[s][i].v]+=(lenth[s]+mp[s][i].d);//这个节点距离根节点的距离。 
        dfs(mp[s][i].v,s);
    }
}

int LCA(int a,int b){
    int l1=lenth[a],l2=lenth[b];//任意两点到根节点的距离 
    if(depth[a]<depth[b]){
        swap(a,b);
    }
    int dif=depth[a]-depth[b];
    for(int i=29;i>=0;i--){
        if(dif>=bit[i]){
            a=pre[a][i];
            dif-=bit[i];
        }
    }
    if(a==b){
        return l1+l2-2*lenth[a];//计算 
        
    }
    for(int i=29;i>=0;i--){
        if(depth[a]>=bit[i]&&pre[a][i]!=pre[b][i]){
            a=pre[a][i];
            b=pre[b][i];
        }
    }
    return l1+l2-2*lenth[pre[a][0]];//计算 
    
}

int main(){
    int t,n,m,a,b,c;
    cin>>t;
    while(t--){
        cin>>n>>m;
        map<int,int>mp1;
        init(n);
        for(int i=1;i<=n-1;i++){
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back({b,c});
            mp[b].push_back({a,c});
        }
        dfs(1,0);
        for(int i=1;i<=m;i++){
            scanf("%d %d)",&b,&c);
            cout<<LCA(b,c)<<endl;
        }
    }
    
    
    
    return 0;
}