LCA && RMQ模版

RMQ（space table算法）

/*
RMQ(Range Minimum/Maximum Query)问题：
   RMQ问题是求给定区间中的最值问题。当然，最简单的算法是O(n)的，但是对于查询次数很多（设置多大100万次），O(n)的算法效率不够。可以用线段树将算法优化到O（logn)（在线段树中保存线段的最值）。不过，Sparse_Table算法才是最好的：它可以在O(nlogn)的预处理以后实现O(1)的查询效率。下面把Sparse Table算法分成预处理和查询两部分来说明(以求最小值为例)。

预处理:
预处理使用DP的思想，f(i, j)表示[i, i+2^j - 1]区间中的最小值，我们可以开辟一个数组专门来保存f(i, j)的值。
例如，f(0, 0)表示[0,0]之间的最小值,就是num[0], f(0, 2)表示[0, 3]之间的最小值, f(2, 4)表示[2, 17]之间的最小值
注意, 因为f(i, j)可以由f(i, j - 1)和f(i+2^(j-1), j-1)导出, 而递推的初值(所有的f(i, 0) = i)都是已知的
所以我们可以采用自底向上的算法递推地给出所有符合条件的f(i, j)的值。

查询:
假设要查询从m到n这一段的最小值, 那么我们先求出一个最大的k, 使得k满足2^k <= (n - m + 1).
于是我们就可以把[m, n]分成两个(部分重叠的)长度为2^k的区间: [m, m+2^k-1], [n-2^k+1, n];
而我们之前已经求出了f(m, k)为[m, m+2^k-1]的最小值, f(n-2^k+1, k)为[n-2^k+1, n]的最小值
我们只要返回其中更小的那个, 就是我们想要的答案, 这个算法的时间复杂度是O(1)的.
例如, rmq(0, 11) = min(f(0, 3), f(4, 3))
*/
#include<iostream>
#include<cmath>
using namespace std;
#define MAXN 1000000
#define mmin(a, b)   ((a)<=(b)?(a):(b))
#define mmax(a, b)   ((a)>=(b)?(a):(b))

int num[MAXN];
int f1[MAXN][100];
int f2[MAXN][100];

//sparse table算法
void st(int n)
{ 
    int i, j, k, m;
    k = (int) (log((double)n) / log(2.0)); 
    for(i = 0; i < n; i++) 
    {
        f1[i][0] = num[i]; //递推的初值
        f2[i][0] = num[i];
    }
    for(j = 1; j <= k; j++)
    { //自底向上递推
        for(i = 0; i + (1 << j) - 1 < n; i++)
        {
            m = i + (1 << (j - 1)); //求出中间的那个值
            f1[i][j] = mmax(f1[i][j-1], f1[m][j-1]);
            f2[i][j] = mmin(f2[i][j-1], f2[m][j-1]);
        }
    }
}

//查询i和j之间的最值,注意i是从0开始的
void rmq(int i, int j) 
{ 
    int k = (int)(log(double(j-i+1)) / log(2.0)), t1, t2; //用对2去对数的方法求出k
    t1 = mmax(f1[i][k], f1[j - (1<<k) + 1][k]);
    t2 = mmin(f2[i][k], f2[j - (1<<k) + 1][k]);
    printf("%d\n",t1 - t2);
}

int main()
{
    int i,N,Q,A,B;
    scanf("%d %d", &N, &Q);
    for (i = 0; i < N; ++i)
    {
        scanf("%d", num+i);
    }

    st(N); //初始化
    while(Q--)
    {
        scanf("%d %d",&A,&B);
        rmq(A-1, B-1);
    }
    return 0;
}

LCA（tarjan算法）

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;
#pragma warning(disable : 4996)

const int MAX = 10005;
int father[MAX];//表示x的父节点
int ranks[MAX];//表示x的秩
int indegree[MAX];//保存每个节点的入度
bool visited[MAX];//标记访问
vector<int> tree[MAX], Ques[MAX];
int ancestor[MAX];

void init(int n)
{
	for(int i = 1; i <= n; i++)
	{

		ranks[i] = 1;
		father[i] = i;
		indegree[i] = 0;
		visited[i] = false;
		ancestor[i] = 0;
		tree[i].clear();
		Ques[i].clear();
	}

}

int find(int x)
{
	if(x != father[x])
	{
		father[x] = find(father[x]);
	}
	return father[x];
}//查找函数，并压缩路径

void Union(int x, int y)
{
	x = find(x);
	y = find(y);
	if(x == y)
	{
		return;
	}
	else if(ranks[x] <= ranks[y])
	{
		father[x] = y;
		ranks[y] += ranks[x];
	}
	else
	{
		father[y] = x;
		ranks[x] += ranks[y];
	}

}//合并函数

void LCA(int u)
{
	int size;
	ancestor[u] = u;
	size = tree[u].size();
	for(int i = 0; i < size; i++)
	{
		LCA(tree[u][i]);
		Union(u, tree[u][i]);
		ancestor[find(u)] = u;
	}
	visited[u] = true;
	size = Ques[u].size();
	for(int i = 0; i < size; i++)
	{
		//如果已经访问了问题节点,就可以返回结果了.
		if(visited[Ques[u][i]])
		{
			printf("%d\n", ancestor[find(Ques[u][i])]);
			return;
		}
	}
}

int main()
{
	freopen("in.txt", "r", stdin);
	int cnt, n, x, y;
	scanf("%d", &cnt);
	while(cnt--)
	{
		scanf("%d", &n);
		init(n);
		for(int i = 1; i < n; i++)
		{
			scanf("%d %d", &x, &y);
			tree[x].push_back(y);
			indegree[y]++;
		}
		//这里可以输入多组询问
		scanf("%d %d", &x, &y);
		//相当于询问两次
		Ques[x].push_back(y);
		Ques[y].push_back(x);
		for(int i = 1; i <= n; i++)
		{
			//寻找根节点
			if(indegree[i] == 0)
			{
				LCA(i);
				break;
			}
		}
	}
	return 0;
}


邻接表实现：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#pragma warning(disable : 4996)
const int MAXN = 40002;
typedef struct Edge
{
	int v;
	int w;
	int next;
}Edge;
int cnt, edge_head[MAXN], ask_head[MAXN];
int father[MAXN], dist[MAXN], ans[201];
bool visited[MAXN];
Edge edge[2 * MAXN], ask[404];

int find(int x)
{
	if (x != father[x])
	{
		father[x] = find(father[x]);
	}
	return father[x];
}

void add_edge(int x, int y, int z)
{
	edge[cnt].v = y;
	edge[cnt].w = z;
	edge[cnt].next = edge_head[x];
	edge_head[x] = cnt++;
}

void add_ask(int x, int y, int cast)
{
	ask[cnt].v = y;
	ask[cnt].w = cast;
	ask[cnt].next = ask_head[x];
	ask_head[x] = cnt++;
}

void Tarjan(int k)
{
	visited[k] = true;

	for (int i = ask_head[k]; i != 0; i = ask[i].next)
	{
		if (visited[ask[i].v])
		{
			ans[ask[i].w] = dist[ask[i].v] + dist[k] - 2 * dist[find(ask[i].v)];
		}
	}

	for (int i = edge_head[k]; i != 0; i = edge[i].next)
	{
		if (!visited[edge[i].v])
		{
			dist[edge[i].v] = dist[k] + edge[i].w;
			Tarjan(edge[i].v);
			edge[i].v = find(edge[i].v);
			father[edge[i].v] = k;
		}
	}

}

int main()
{
	freopen("in.txt", "r", stdin);
	int i, m, n;
	int x, y, z;
	int t;
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d %d", &n, &m);
		for (i = 1; i <= n; i++)
		{
			edge_head[i] = ask_head[i] = 0;
			father[i] = i;
			visited[i] = false;
		}

		cnt = 1;
		for (i = 1; i < n; i++)
		{
			scanf("%d%d%d", &x, &y, &z);
			add_edge(x, y, z);
			add_edge(y, x, z);
		}
		cnt = 1;
		for (i = 1; i <= m; i++)
		{
			scanf("%d%d", &x, &y);
			add_ask(x, y, i);
			add_ask(y, x, i);
		}
		dist[1] = 0;
		Tarjan(1);

		for (i = 1; i <= m; i++)
			printf("%d\n", ans[i]);
	}
	return 0;
}

另附一个个人感觉比较好的模版，主要是实用性强。

/*
 *算法引入:
 *树上两点的最近公共祖先;
 *对于有根树的两个结点u,v,最近公共祖先LCA(T,u,v)表示一个结点x,满足x是u,v的祖先且x的深度尽可能大;
 *对于x来说,从u到v的路径一定经过点x;
 *
 *算法思想:
 *Tarjan_LCA离线算法;
 *Tarjan算法基于dfs的框架,对于新搜到的一个结点,首先创建由这个结点构成的集合,再对当前结点的每个子树进行搜索;
 *每搜索完一棵子树,则可确定子树内的LCA询问都已解决,其他的LCA询问的结果必然在这个子树之外;
 *这时把子树所形成的集合与当前结点的集合合并,并将当前结点设为这个集合的祖先;
 *之后继续搜索下一棵子树,直到当前结点的所有子树搜完;
 *
 *这时把当前结点也设为已被检查过的,同时可以处理有关当前结点的LCA询问;
 *如果有一个从当前结点到结点v的询问,且v已经被检查过;
 *则由于进行的是dfs,当前结点与v的最近公共祖先一定还没有被检查;
 *而这个最近公共祖先的包含v的子树一定已经搜索过了,那么这个最近公共祖先一定是v所在集合的祖先;
 *
 *算法步骤:
 *对于每一个结点:
 *(1)建立以u为代表元素的集合;
 *(2)遍历与u相连的结点v,如果没有被访问过,对于v使用Tarjan_LCA算法,结束后将v的集合并入u的集合;
 *(3)对于与u有关的询问(u,v),如果v被访问过,则结果就是v所在集合的代表元素;
 *
 *算法示例:
 *HDU2586(How far away?)
 *
 *题目大意:
 *求树上任两点间的距离;
 *
 *算法思想:
 *先dfs一遍,求出到根节点的dis;
 *对于某个询问,求u和v的lca,然后res[i]=d[u]+d[v]-2*d[lca(u,v)];
 *
**/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#pragma warning(disable : 4996)

const int MAXN = 40004;

int father[MAXN];
int head[MAXN*2];
int qhead[MAXN];//询问
bool visited[MAXN];

int dist[MAXN];
int ans[MAXN];

typedef struct node
{
    int to;
    int w;
    int next;
    int lca;
}node;

node edge[MAXN*2];
node qedge[MAXN];//询问边

int n,m;
int cnt1, cnt2;

void Addedge(int u, int v, int w)
{
    edge[cnt1].w = w;
    edge[cnt1].to = v;
    edge[cnt1].next = head[u];
    head[u] = cnt1;
    cnt1++;

    edge[cnt1].w = w;
    edge[cnt1].to = u;
    edge[cnt1].next = head[v];
    head[v] = cnt1;
    cnt1++;
}

void Addqedge(int u, int v)
{
    qedge[cnt2].to = v;
    qedge[cnt2].next = qhead[u];
    qhead[u] = cnt2;
    cnt2++;

    /*qedge[cnt2].to=u;
    qedge[cnt2].next=qhead[v];
    qhead[v]=cnt2;
    cnt2++;*/
}

void dfs(int u, int f, int w)
{
    dist[u] = w;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v == f)
		{
            continue;
		}
        dfs(v, u, w + edge[i].w);
    }
}

int Find(int x)
{
    if(x != father[x])
	{
		father[x] = Find(father[x]);
	}
    return father[x];
}

void Tarjan_LCA(int u)//离线LCA算法
{
    father[u] = u;
    visited[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        if(!visited[edge[i].to])
        {
            Tarjan_LCA(edge[i].to);
            father[edge[i].to] = u;
        }
    }

    for(int i = qhead[u]; i != -1; i = qedge[i].next)
    {
        if(visited[qedge[i].to])
        {
            qedge[i].lca = Find(qedge[i].to);
            //printf("%d和%d的最近公共祖先为: %d\n",u,qedge[i].to,qedge[i].lca);
            ans[i] = dist[u] + dist[qedge[i].to] - 2 * dist[qedge[i].lca];
           // qedge[i+1].lca=qedge[i].lca;
        }
    }
}

void init()
{
    for(int i = 0; i <= n; i++)
	{
        father[i] = i;
		head[i] = -1;
		qhead[i] = -1;
		visited[i] = false;
	}
    cnt1 = cnt2 = 0;
    int u, v, w;
    for(int i = 1; i < n; i++)
    {
        scanf("%d %d %d", &u, &v, &w);
        Addedge(u, v, w);
    }

    for(int i = 0; i < m; i++)
    {
        scanf("%d %d", &u, &v);
        Addqedge(u, v);
    }

    dfs(1, 0, 0);
    Tarjan_LCA(1);
}

int main()
{
    freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &m);
        init();
        for(int i = 0; i < m; i++)
		{
            printf("%lld\n", ans[i]);
		}
    }
    return 0;
}