Lowest Common Ancestor

已于 2022-04-13 19:59:17 修改
阅读量94 收藏
点赞数
分类专栏： 学习 文章标签： c++ 数据结构
于 2022-04-06 17:13:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45419976/article/details/123994561
版权

文章目录

luoguP3379板子题

代码：
现写的一份，是单纯的LCA

#include<iostream>
using namespace std;
const int N = 500005;
int en = 0,head[N] = {0};
struct Edge{
	int to,next;
	int val;
}edge[N*2];
int n,m,q,a,b,c,rt;
int fa[N][21] = {0},depth[N] = {0},w[N] = {0};

void add(int u,int v){
	edge[++en].to = v;
	edge[en].next = head[u];
	head[u] = en;
}

void dfs(int u,int father){
	depth[u] = depth[father]+1;
	fa[u][0] = father;
	for(int i=1;(1<<i)<=depth[u];i++){
		fa[u][i] = fa[fa[u][i-1]][i-1];
	}
	for(int p=head[u]; p ;p=edge[p].next){
		int v = edge[p].to;
		if(v!=father) {
			w[v] = w[u]+edge[p].val ;
			dfs(v,u);
		}
	}
}

int lca(int u,int v){
	if(depth[u]<depth[v]) swap(u,v);
	for(int i=20;i>=0;i--){
		if(depth[fa[u][i]]>=depth[v])
			u = fa[u][i];
	}
	if(u==v) return u;
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		}
	}
	return fa[u][0];
}

void query(int u,int v){
	int x = lca(u,v);
	int ans = w[u]+w[v]-2*w[x];
//	printf("%d\n",ans);
	printf("%d\n",x);
} 

int main(){
	scanf("%d%d%d",&n,&q,&rt);
	for(int i=1;i<n;i++){
		scanf("%d%d",&a,&b);
		add(a,b);
		add(b,a);
	}
	dfs(rt,0);
	for(int i=1;i<=q;i++){
		scanf("%d%d",&a,&b);
		query(a,b);
	}
	return 0;
}

这份疑似是树链剖分………………无语住了就是说，我已经忘记什么是top了…… 是每条链的顶端结点

#include<bits/stdc++.h>
using namespace std;
const int N = 500005;
int en,n,m,s,head[N],depth[N],father[N],son[N],f[N][21],top[N],size[N];
struct Edge{
	int to,next;
}edge[N<<1];
inline void read(int &x){
	char ch;
	while((ch = getchar())<'0' || ch>'9') ;
	for(x=0;ch<='9'&&ch>='0';ch = getchar())
		x = x*10+ch-'0';
}

inline void add(int x,int y){
	edge[en].to = y;
	edge[en].next = head[x];
	head[x] = en++;
}

void init(){
	read(n);read(m);read(s);
	memset(head,-1,sizeof(head));
	for(int i=1,x,y;i<n;i++){
		read(x);read(y);
		add(x,y);
		add(y,x);
	}
}

void dfs1(int u,int f){
	depth[u] = depth[f]+1;
	size[u] = 1;
	father[u] = f;
	for(int p = head[u],v;~p;p = edge[p].next ){
		v = edge[p].to ;
		if(v==f) continue;
		dfs1(v,u);
		size[u] += size[v];
		if(size[v]>size[son[u]])
			son[u] = v;
	}
}

void dfs2(int u){
	if(son[u]) {
		top[son[u]] = top[u];
		dfs2(son[u]);
	}
	for(int v,p = head[u];~p;p = edge[p].next ){
		v = edge[p].to ;
		if(top[v]) continue;
		top[v] = v;
		dfs2(v);
	}
}

int lca(int x,int y){
	while (top[x]!=top[y]) {
		if(depth[top[x]]<depth[top[y]]) swap(x,y);
		x = father[top[x]];
	}
	return depth[x]<depth[y]?x:y;
}

void solve(){
	for(int i=0,x,y;i<m;i++){
		read(x);read(y);
		printf("%d\n",lca(x,y));
	}
}

int main(){
	init();
	dfs1(s,0);
	top[s] = s;
	dfs2(s);
	solve();
}

树上最短路

每条边有权值的，问两点间最短路

#include<iostream>
using namespace std;
const int N = 100005;
int en = 0,head[N] = {0};
struct Edge{
	int to,next;
	int val;
}edge[N*2];
int n,m,q,a,b,c;
int fa[N][21] = {0},depth[N] = {0},w[N] = {0};

void add(int u,int v,int _val){
	edge[++en].to = v;
	edge[en].next = head[u];
	head[u] = en;
	edge[en].val = _val;
}

void dfs(int u,int father){
	depth[u] = depth[father]+1;
	fa[u][0] = father;
	for(int i=1;(1<<i)<=depth[u];i++){
		fa[u][i] = fa[fa[u][i-1]][i-1];
	}
	for(int p=head[u]; p ;p=edge[p].next){
		int v = edge[p].to;
		if(v!=father) {
			w[v] = w[u]+edge[p].val ;
			dfs(v,u);
		}
	}
}

int lca(int u,int v){
	if(depth[u]<depth[v]) swap(u,v);
	for(int i=20;i>=0;i--){
		if(depth[fa[u][i]]>=depth[v])//要加等号…… 
			u = fa[u][i];
	}
	if(u==v) return u;
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		}
	}
	return fa[u][0];
}

void query(int u,int v){
	int x = lca(u,v);
	int ans = w[u]+w[v]-2*w[x];
	printf("%d\n",ans);
} 

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	dfs(1,0);
	scanf("%d",&q);
	for(int i=1;i<=q;i++){
		scanf("%d%d",&a,&b);
		query(a,b);
	}
	return 0;
}

tips:

  • 记得写lca的时候开fa[N][21],因为20的话会超出范围……
  • 记得写lca的时候，第一次要挪到depth相等的时候要取>=，否则根本等不了的，然后导致lca出错

三点最短路

在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 50005;
int fa[N][18] = {0};
int depth[N] = {0},val[N] = {0},head[N] = {0};
int en,n,q,a,b,c;
struct Edge{
	int next,to;
	int value;
}edge[N*2];

void add(int u,int v,int w){
	edge[++en].to = v;
	edge[en].next = head[u];
	head[u] = en;
	edge[en].value = w;
}

void dfs(int u,int father){
	depth[u] = depth[father]+1;
	fa[u][0] = father;
	for(int i=1;(1<<i)<=depth[u];i++){
		fa[u][i] = fa[fa[u][i-1]][i-1];
	}
	for(int p=head[u]; p ;p=edge[p].next){
		int v = edge[p].to ;
		if(v!=father){
			val[v] = val[u]+edge[p].value ;
			dfs(v,u);
		}
	} 
}

int lca(int u,int v){
	if(depth[u]<depth[v]) swap(u,v);
	for(int i=17;i>=0;i--){
		if(depth[fa[u][i]]>=depth[v])
			u = fa[u][i];
	}
	if(u==v) return u;
	for(int i=17;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		}
	}
	return fa[u][0];
}

int solve(int u,int v){
	if(depth[u]<depth[v]) swap(u,v);
	int x = lca(u,v);
	return val[u]+val[v]-2*val[x];
}

void query(int u,int v,int w){//uvw是节点啦 
	int x = lca(u,v);
	int y = lca(u,w);
	int z = lca(v,w);
	int ans = 0;
	if(depth[x]>=depth[y] && depth[x]>=depth[z]){
		ans = solve(u,v);
		ans += solve(w,lca(u,v));
	}
	else if(depth[y]>=depth[x] && depth[y]>=depth[z]){
		ans = solve(u,w);
		ans += solve(v,lca(u,w));
	}
	else if(depth[z]>=depth[x] && depth[z]>=depth[y]){
		ans = solve(v,w);
		ans += solve(u,lca(v,w));
	}
	printf("%d\n",ans);
	return ;
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<n;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	dfs(1,0);
	scanf("%d",&q);
	for(int i=1;i<=q;i++){
		scanf("%d%d%d",&a,&b,&c);
		query(a,b,c);
	}
	return 0;
}

一开始的算法有缺陷……并不是那样做的……打了一些草稿后才明白是应该分这样几种情况
在这里插入图片描述

统一的做法是每次找到三个lca中最深的一个，然后爬上去，爬上去后处理另一个。

Marinia

在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 100005;
int n,m,x,y,t,k,a,b;
int fa[N][21] = {0},depth[N] = {0};//果然……这里超出范围了，写21而不是20 
int tot;
int good[N][32] = {0}; 
bool need[32] = {0};
struct Edge{
	int to,next;
}edge[N*2];
int head[N] = {0};
int en = 0;

void add(int u,int v){
	edge[++en].to = v;
	edge[en].next = head[u];
	head[u] = en;
}

void dfs(int u,int father){
	fa[u][0] = father;
	depth[u] = depth[father] +1;
	for(int i=0;i<m;i++){
		good[u][i] += good[father][i];//从最顶上到自己（含自己）的货物量 
	}
	for(int i=1;(1<<i)<=depth[u];i++){
		fa[u][i] = fa[fa[u][i-1]][i-1];
	}
	for(int p=head[u];p;p=edge[p].next){
		int v = edge[p].to ;
		if(v!=father) dfs(v,u);
	}
}

bool query(int u,int v){
	int tmpu = u,tmpv = v;	
	for(int i=0;i<m;i++){
		u = tmpu;
		v = tmpv;
		if(need[i]==false) continue;
		bool f = false;
		if(depth[u]<depth[v]) swap(u,v);
		for(int j=20;j>=0;j--){
			if(depth[fa[u][j]]>=depth[v]){//可以上跳 
				if(good[u][i]-good[fa[u][j]][i]>0) f = true;
				u = fa[u][j];
			}
		}
		if(f==true) continue;
		if(u==v) {
			if(good[u][i]-good[fa[u][0]][i]>0) f = true;
			if(f) continue;
			if(!f) return false;
		}
		for(int j=20;j>=0;j--){
			if(fa[u][j]!=fa[v][j]){
				if(good[u][i]-good[fa[u][j]][i]>0) f = true;
				if(good[v][i]-good[fa[v][j]][i]>0) f = true;
				u = fa[u][j];
				v = fa[v][j];
			}
		}
		if(good[u][i]-good[fa[u][1]][i]>0) f = true;
		if(good[v][i]-good[fa[v][1]][i]>0) f = true;
		if(!f) return false;
	}
	return true;
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%d",&tot);
		for(int j=1;j<=tot;j++){
			scanf("%d",&x);
			good[i][x]++;
		}
	}
	for(int i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);
	}
	dfs(1,0);
	scanf("%d",&k);
	for(int i=1;i<=k;i++){
		scanf("%d%d%d",&a,&b,&t);
		for(int j=0;j<32;j++){
			need[j] = 0;
		}
		for(int j=1;j<=t;j++){
			scanf("%d",&x);//小心变量被你自己重复使用，还不如多开几个…… 
			need[x] = true;
		}
		if(query(a,b)) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

考前没有复习，导致考场上现场回忆链式前向星，写的是一个歪七扭八的版本，两个小时才拿了十分……
和前面的tips差不多：

  • 记得开fa[N][21]，否则会超出范围，导致出错，具体出错的机理还不明确，只知道在找lca的途中会在第一层循环里面进行很多遍，应该是到20下标那里胡乱进行了一些赋值
  • 呃呃呃呃我很喜欢在输入变量多的时候进行一些变量的共用，可是很容易出错因为后面的可能会把前面的覆盖掉……fine，以后小心一点为好

树上路径交叉

在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 100005;
int T,n,m,x,y,x1,y1,x2,y2;
int head[N] = {0},depth[N] = {0};
int fa[N][18] = {0};
struct Edge{
	int to,next;
}edge[N*2];
int en;

void add(int u,int v){
	edge[++en].to = v;
	edge[en].next = head[u];
	head[u] = en;
}

void dfs(int u,int father){
	depth[u] = depth[father]+1;
	fa[u][0] = father;
	for(int i=1;(1<<i)<=depth[u];i++){
		fa[u][i] = fa[fa[u][i-1]][i-1]; 
	}
	for(int p=head[u];p;p=edge[p].next){
		int v = edge[p].to ;
		if(v != father){
			dfs(v,u);
		}
	}
}

int lca(int u,int v){
	if(depth[u]<depth[v]) swap(u,v);
	for(int i=17;i>=0;i--){
		if(depth[fa[u][i]]>=depth[v]){
			u = fa[u][i];
		}
	}
	if(u==v) return u;
	for(int i=17;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		} 
	}
	return fa[u][0];
}

bool check(int u1,int v1,int u2,int v2){
	int lca1 = lca(u1,v1);
	int lca2 = lca(u2,v2);
	if((lca(lca1,u2)==lca1 || lca(lca1,v2)==lca1) && depth[lca1]>=depth[lca2]) return true;
	if((lca(lca2,u1)==lca2 || lca(lca2,v1)==lca2) && depth[lca2]>=depth[lca1]) return true;
	return false;
}

int main(){
	scanf("%d",&T);
	while(T--){
		en = 0;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++){
			head[i] = 0;
			for(int j=0;j<18;j++){
				fa[i][j] = 0;
			}
		}	
		for(int i=1;i<n;i++){
			scanf("%d%d",&x,&y);
			add(x,y);
			add(y,x);
		}
		dfs(1,0);
		for(int i=1;i<=m;i++){
			scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
			if(check(x1,y1,x2,y2))
				printf("YES\n");
			else printf("NO\n");
		}
	}
	return 0;
}

这里的思路是，若其中一条链的lca在另一条链上，则路径有交叉。而一点在链上有两种写法，第一种是：(lca(x,u)==x||lca(x,v)==x)&&depth[x]<=lca(u,v)；第二种是：dis(u,v)==dis(x,u)+dis(x,v)
试试第二种哈：

int dis(int u,int v){
	return depth[u]+depth[v]-2*depth[lca(u,v)];
}

bool check(int u1,int v1,int u2,int v2){
	int lca1 = lca(u1,v1);
	int lca2 = lca(u2,v2);
	if(dis(lca1,u2)+dis(lca1,v2)==dis(u2,v2)) return true;
	if(dis(lca2,u1)+dis(lca2,v1)==dis(u1,v1)) return true;
	return false;
}
矿矿不想吃饭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java:实现Lowest Common Ancestor最近公共祖先算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-31 186
Java:实现Lowest Common Ancestor最近公共祖先算法（附完整源码）
最近公共祖先 (Lowest common ancestor)
Yuwen's Hero
06-05 6267
问题： 给定一个二叉树，找到两个节点NA， NB的最近公共祖先(LCA)。 比如对于下图，4 和 7 的 LCA 是6， 1和13的LCA 是 8。 分析： 我们这里先考虑一般的二叉树(BT)，然后再考虑这个二叉树是二叉搜索树(BST)的情况。 查找两个node的最早的公共祖先，分三种情况： 1. 如果两个node在root的两边，那么最早的公共祖先就是root。
Lowest Common Ancestor(LCA)
Jiajun Zhu
05-28 590
1.是二叉搜索树struct TreeNode { int val; TreeNode *left,*right; }; TreeNode *LCA(TreeNode *root,TreeNode *p1,TreeNode *p2) { while(true) { if(root->val>p1->val&&roo
剑指offer4-（LCA）Lowest Common Ancestor
小羊哈利
10-05 566
题目可以参考leetcode，写完顺便可以用leetcode OJ测试一下自己代码的正确性。这一题不难，一般的递归思想就可以解决。但当时面试京东的时候，别人总说我遍历了两次，能否只遍历一次？后来看剑指offer的面试题39：二叉树的深度，解法中利用后序遍历有提到每个节点只遍历一次，所以基于此我把LCM列为剑指offer，以供参考。/** * Definition for a binary tree
Lowest Common Ancestor of Deepest Leaves
01-20
在给定的问题中，我们需要解决的是“最低共同祖先（Lowest Common Ancestor, LCA）”问题，但针对的是二叉树中最深叶子节点。这是一个经典的计算机科学问题，特别是在数据结构和算法领域。二叉树是一种特殊的树结构...
Binary Tree – Lowest Common Ancestor 题型总结
01-06
Lowest Common Ancestor of a Binary Search Tree  Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. According to the definition of LCA on Wikipedia:...
Range Minimum Query and Lowest Common Ancestor[翻译]1
08-08
Range Minimum Query (RMQ) 和 Lowest Common Ancestor (LCA) 是两种在计算机科学和算法设计中常见的数据结构和问题。在这篇文章的翻译中，主要介绍了这两种概念以及它们的关联和解决方案。 首先，Range Minimum ...
1123.Lowest Common Ancestor of Deepest Leaves最深叶节点的最近公共祖先【LeetCode单题讲解系列】
08-31
1123.Lowest_Common_Ancestor_of_Deepest_Leaves最深叶节点的最近公共祖先【LeetCo
最近公共祖先LCA(C++版).docx
05-20
最近公共祖先（Lowest Common Ancestor，LCA） 最近公共祖先（Lowest Common Ancestor，LCA）是指在一棵树上，两个节点的最近公共祖先节点。也就是说，两个点在这棵树上的距离最近的公共祖先节点。LCA 是一个基本...
1143. Lowest Common Ancestor (30)
zcc的博客
03-18 603
1143. Lowest Common Ancestor (30)见过最简单的一个代码#include&lt;bits/stdc++.h&gt; using namespace std; int n,m,u,v,a; map&lt;int,bool&gt;q; int main(){ scanf("%d%d",&amp;m,&amp;n); vector&lt;int&gt;pr...
1143. Lowest Common Ancestor
qq_36317051的博客
03-20 294
还是3.18的考试，写题速度太慢了，最后一题建树之后没多少时间了。还有就是java写久了，指针全光了，并且对树这种结构不太熟练。没想好如何利用二叉查找树这种特殊的数据结构，其实要查u、v，对于某个节点node,如果node.key在u和v之间的话，该节点就是那个lowest common ancestor。后来还有一个测试点没过，想了想是如果u==v的话，要按照这种格式输出But if A is ...
[leetcode] LowestCommonAncestor
nwpuxhld
05-16 1126
LowestCommonAncestor 问题描述：给定一颗二叉树，和二叉树的两个节点，计算出这两个节点的最低公公祖先。 解法1: 最低公公祖先可能出现的最高值就是根节点。 我们找到从根节点到两个节点的路径，path1和path2. 则两者一定是Y字型或者是V字形(root节点) 则我们就把问题转化成了计算两个list的相交点问题。 首先长的path先走他们之间长度差值步，使得后续的两个pat...
Lowest Common Ancestor（位运算）
Spike的秃头之路
03-16 137
题目链接： https://ac.nowcoder.com/acm/contest/12794/J 十六进制每位转化为四位二进制 #include <iostream> #include <algorithm> #include <cstring> #include <vector> #include <stack> #include <cmath> using namespace std; #define ll long long
【PAT 1143】 Lowest Common Ancestor 【C++版】
说文科技，做有态度的研究。
05-01 426
1143 Lowest Common Ancestor 【C++版】 给出一个二叉搜索树的先序序列，让你求出其两个节点的最小公共父节点。
1143 Lowest Common Ancestor (30分)
weixin_45748610的博客
11-22 104
#include <iostream> #include <vector> #include <algorithm> using namespace std; const int SIZE = 80000; int postOrder[SIZE]; int path[SIZE]; int res; struct Node { int data; Node* left, * right; Node() { left = right = NULL; }
Lowest Common Ancestor II
leetcode 解题思路
11-07 156
Given the root and two nodes in a Binary Tree. Find the lowest common ancestor(LCA) of the two nodes. The lowest common ancestor is the node with largest depth which is the ancestor of both nodes. T...
CShap 二叉树的lowest common ancestor 源代码
最新发布
04-01
以下是C#中二叉树的lowest common ancestor的源代码： ```csharp using System; public class Node { public int value; public Node left; public Node right; public Node(int value) { this.value = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值