LCA(最近公共祖先) (倍增法和Tarjan)

 首先我们要知道什么是LCA：
                什么是最近公共祖先？？
                                    就是深度最大的公共祖先

例子：

 LCA(2,1)=4//结点2和结点1的最近公共祖先是4；

 LCA(2,4)=4//结点2和结点4的最近公共祖先是4；

 LCA(5,2)=4//结点5和结点2的最近公共祖先是4；

倍增法的定义：

倍增是暴力的优化

所以我们先看看暴力的思路：
倍增是利用二进制的一些特性=-=可以通过数据之间的关系来快速进行运算。（我知道你不知道任何数都可以化成2进制的式子）

求LCA的方法：

1.要把各个结点的深度求出来。
比如我们要去求3和2的LCA。
我们求得dep[结点3] = 2，dep[结点2] = 1;
2.要把这两个结点放在同一层。（dep[i]==dep[j]）
3.深度一样后我们再把两只结点一起跳，跳到结点相同即可!

可是我知道一个一个的处理会太麻烦了！！！！！！！！！！！！！！

有什么优化的地方吗？（没有！！）

用倍增的思想：
就是我们跳的时候优化，跳2的倍数。
1.fa[i][j]表示结点i跳2^j次方后的位置，也就是说2 ^ j次方代的祖先

预处理出往上走2^j次方的主线。
显然当j = 0的时候，i走到的是i的父结点

2.当我们求解的两个结点的深度不一样的时候。我们需要把深度较大的结点往上移。使得与深度较小的结点平齐。

3.两个结点的高度在同一层了，现在需要一起往上跳。
这个地方我们只能从小往大处理。
因为两个结点的公共祖先可能不止一个。
如果从大往小处理的话可能直接跳过了最近的公共祖先。跑到其他的公共祖先上去了（不是最近）

4.代码中特判了一下（有可能要求的某一个结点就是LCA，所以当处理到高度相同的时候两个结点相等，就可以直接返回了）

LCA(倍增）模板：

题目：洛谷P3379 【模板】最近公共祖先（LCA）

#include<bits/stdc++.h>
using namespace std;
const int  N=5e5+5;
struct Edge{
	int to;
	int next;
}edge[2*N];
int n,m,s,lg[N];
int head[N],cnt;
int dep[N],f[N][50];
void insert_(int x,int y)
{
	edge[++cnt].to=y;
	edge[cnt].next=head[x];
	head[x]=cnt;
}
void dfs(int now,int fa)
{
	f[now][0]=fa;
	dep[now]=dep[fa]+1;
	for(int i=1;i<=lg[dep[now]];i++)
		f[now][i]=f[f[now][i-1]][i-1];
	for(int i=head[now];i;i=edge[i].next)
		if(edge[i].to!=fa)dfs(edge[i].to,now);
}
int LCA(int x,int y)
{
	if(dep[x]<dep[y])swap(x,y);
	while(dep[x]>dep[y])
		x=f[x][lg[dep[x]-dep[y]]-1];
	if(x==y)return x;
	for(int k=lg[dep[x]]-1;k>=0;k--)
	{
		if(f[x][k]!=f[y][k])
		{
			x=f[x][k];
			y=f[y][k];
		}
	}
	return f[x][0];
}
int main(){
scanf("%d%d%d",&n,&m,&s);
	for(int i=1;i<n;i++)
	{
		int cx,cy;
		scanf("%d%d",&cx,&cy);
		insert_(cx,cy);
		insert_(cy,cx);
	}
	for(int i=1;i<=n;i++)
		lg[i]=lg[i-1]+((1<<lg[i-1])==i);
	dfs(s,0);
	while(m--)
	{
		int qx,qy;
		scanf("%d%d",&qx,&qy);
		printf("%d\n",LCA(qx,qy));
	}
	return 0;
} 

    EMM~~~~~Tarjan的我不会！！！！！！！！   

以下是LCA（Tarjan）的用法：

1. 首先，需要构建一棵树的数据结构，并将其存储在一个二维数组中（即邻接矩阵或邻接表）。

2. 然后，需要定义一个数组low和数组dfn来跟踪每个节点的发现顺序和其在搜索树中的位置。

3. 接下来，定义一个数组ancestor，其中每个节点都指向其在搜索树中的祖先节点。

4. 接着，使用深度优先搜索（DFS）遍历树。

5. 在DFS过程中，对于每个访问的节点，更新其dfn和low值，并将其添加到一个堆栈中以进行后续处理。

6. 当遍历到一个节点u的子节点v时，需要考虑以下情况：

   a. 如果节点v已经被访问过，但不在堆栈中，则更新节点u的low值为min(low[u], dfn[v])。

   b. 如果节点v在堆栈中，则更新节点u的low值为min(low[u], low[v])。

7. 当DFS返回到节点u时，检查堆栈中u的所有子节点v，并将它们全部弹出。然后，如果u不是根节点且low[u]等于dfn[u]，则u的祖先节点是堆栈中所有已弹出节点的最近公共祖先。

8. 最后，将u的祖先节点更新为其在搜索树中的最终祖先，并将其返回。

下面是一个使用LCA（Tarjan）算法查找两个节点的最近公共祖先的示例代码：```
 

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100010;

int n, m, tot, head[MAXN], vis[MAXN], dfn[MAXN], low[MAXN], anc[MAXN];
stack<int> s;

struct Edge {
    int to, nxt;
} edge[MAXN << 1];

void addEdge(int u, int v) {
    edge[++tot].to = v;
    edge[tot].nxt = head[u];
    head[u] = tot;
}

void Tarjan(int u, int fa) {
    dfn[u] = low[u] = ++tot;
    s.push(u);
    for (int i = head[u]; i; i = edge[i].nxt) {
        int v = edge[i].to;
        if (v == fa) continue;
        if (!dfn[v]) {
            Tarjan(v, u);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                int x; ++tot;
                do {
                    x = s.top(); s.pop();
                    anc[x] = tot; vis[x] = 1;
                } while (x != v);
                anc[u] = tot; vis[u] = 1;
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if (dfn[u] == low[u]) {
        int x;
        do {
            x = s.top(); s.pop();
            anc[x] = tot; vis[x] = 1;
        } while (x != u);
    }
}

int LCA(int u, int v) {
    while (anc[u] != anc[v]) {
        if (dfn[anc[u]] < dfn[anc[v]]) swap(u, v);
        u = anc[u];
    }
    return dfn[u] < dfn[v] ? u : v;
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        int u, v;
        scanf("%d %d", &u, &v);
        addEdge(u, v); addEdge(v, u);
    }
    for (int i = 1; i <= n; ++i) {
        if (!dfn[i]) {
            tot = 0;
            Tarjan(i, 0);
        }
    }
    int q;
    scanf("%d", &q);
    while (q--) {
        int u, v;
        scanf("%d %d", &u, &v);
        printf("%d\n", LCA(u, v));
    }
    return 0;
}