HDU 5266 pog loves szh III 线段树，lca

Pog and Szh are playing games. Firstly Pog draw a tree on the paper. Here we define 1 as the root of the tree.Then Szh choose some nodes from the tree. He wants Pog helps to find the least common ancestor (LCA) of these node.The question is too difficult for Pog.So he decided to simplify the problems.The nodes picked are consecutive numbers from lili to riri ([li,ri])([li,ri]).

Input

Several groups of data (no more than 3 groups,n≥10000n≥10000 or Q≥10000Q≥10000). 
The following line contains ans integers,n(2≤n≤300000)n(2≤n≤300000). 
AT The following n−1n−1 line, two integers are bibi and cici at every line, it shows an edge connecting bibi and cici. 
The following line contains ans integers,Q(Q≤300000)Q(Q≤300000). 
AT The following QQ line contains two integers li and ri(1≤li≤ri≤n1≤li≤ri≤n).

Output

For each case,output QQ integers means the LCA of [li,ri][li,ri].

Sample Input

5
1 2
1 3
3 4
4 5
5
1 2
2 3
3 4
3 5
1 5

Sample Input

1
1
3
1
1

一颗树以1为根节点，给出区间范围，求范围内所有点的lca公共祖先，之前学的lca算法只能求两个点的，但考虑到是区间内进行操作，故考虑线段树。这道题如果了解线段树的话可以说没什么难度了...
做这道题这道题之前，没学过线段树...搞了好久才弄清楚，在网上抄了个线段树模板，弄清楚后没有想象中的难，实际上就是简单的lca+线段树组合罢了，可以说是模板题也不为过，收获就是学会了bfs树上倍增和搞清楚了线段树吧，
这个数据结构挺神奇的。
该题G++提交会TLE，C++提交如果不手动扩栈就会爆栈，当然也可以用BFS倍增就不用担心爆栈了。

 #include <iostream>
 #include <string.h>
 #include <stdio.h>
 #include <math.h>
 #include <cstdio>
 #include <queue>
 #pragma warning ( disable : 4996 )
 #pragma comment(linker, "/STACK:102400000,102400000")  //防止爆栈

 using namespace std;

 int Max( int x, int y ) { return x>y?x:y; }
 int Min( int x, int y ) { return x>y?y:x; }

 const int inf = 0x3f3f3f3f;
 const int vspot = 3e5 + ;
 const int espot = 1e5 + ;

 struct node {
     int from, to, next;
 }e[vspot<<];

 int N, Q, cnt, logn;
 int lca[vspot<<], linjie[vspot];
 int fa[vspot][], depth[vspot];

 void addedge(int u, int v)
 {
     e[cnt].from = u; e[cnt].to = v;
     e[cnt].next = linjie[u]; linjie[u] = cnt++;
     e[cnt].from = v; e[cnt].to = u;
     e[cnt].next = linjie[v]; linjie[v] = cnt++;
 }

 void init()
 {
     cnt = ;
     logn = ;
     memset( linjie, -, sizeof(linjie) );
     memset( lca, , sizeof(lca) );
     memset( depth, , sizeof(depth) );
     memset( fa, , sizeof(fa) );
 }

 void dfs( int x )
 {
     for( int i = ; i <= logn; i++ )
         if ( fa[x][i-] )
             fa[x][i] = fa[fa[x][i-]][i-];
         else
             break;
     for ( int i = linjie[x]; i+; i = e[i].next )
         if ( fa[x][] != e[i].to )
         {
             fa[e[i].to][] = x;
             depth[e[i].to] = depth[x]+;
             dfs(e[i].to);
         }
 }

 void bfs( int x )
 {
     queue<int> Q;
     Q.push(x);

     while (!Q.empty())
     {
         int run = Q.front();
         Q.pop();
         for( int i = linjie[run]; i+; i = e[i].next )
             if ( fa[run][] != e[i].to )
             {
                 fa[e[i].to][] = run;
                 depth[e[i].to] = depth[run] + ;
                 Q.push(e[i].to);
             }
     }
 }

 void init2()
 {
     for ( int i = ; i <= logn; i++ )
         for ( int x = ; x <= N; x++ )
             fa[x][i+] = fa[fa[x][i]][i];
 }

 int Lca( int u, int v )
 {
     if ( depth[u] < depth[v] )
         swap(u,v);
     int d = depth[u] - depth[v];
     for ( int i = ; i <= logn; i++ )
         if( (<<i)&d )
             u = fa[u][i];

     if ( u == v ) return u;
     for ( int i = logn; i >= ; i-- )
         if ( fa[u][i] != fa[v][i] )
         {
             u = fa[u][i];
             v = fa[v][i];
         }
     return fa[u][];
 }

 void pushUp( int pos ) { lca[pos] = Lca(lca[pos<<], lca[pos<<|]); }

 void build( int lhs, int rhs, int id )
 {
     if ( lhs == rhs )
     {
         lca[id] = lhs;
         return;
     }
     int mid = ( lhs + rhs ) >> ;
     build( lhs, mid, id<< );
     build( mid+, rhs, id<<| );

     pushUp(id);
 }

 //lhs, rhs表示当前节点的区间，l，r表示要操作的区间
 int query( int lhs, int rhs, int l, int r, int id )
 {
     if ( l <= lhs && r >= rhs )
         return lca[id];
     int mid = (lhs+rhs)>>;

     int llca = -, rlca = -;
     if ( l <= mid ) llca = query( lhs, mid, l, r, id<< );
     if ( r >  mid ) rlca = query( mid+, rhs, l, r, id<<| );

     if ( llca == - || rlca == - )
         return Max(llca, rlca);
     else
         return Lca(llca, rlca);
 }

 int main()
 {
     while ( ~scanf("%d", &N) )
     {
         init();
         int x, y;
         for( int i = ; i < N; i++ )
             { scanf("%d %d", &x, &y ); addedge(x,y); }
         bfs();
         init2();
         // dfs(1);   用dfs并去掉上面两行也行
         build(,N,);

         cin >> Q;
         int ans;
         for ( int i = ; i <= Q; i++ )
         {
             scanf( "%d %d", &x, &y );
             ans = query( , N, x, y,  );
             printf( "%d\n", ans );
         }
     }
     return ;
 }