最近公共祖先（朴素法、倍增法、（递归法））

最新推荐文章于 2024-05-10 09:36:12 发布
最新推荐文章于 2024-05-10 09:36:12 发布
阅读量758 收藏 1
点赞数
分类专栏： 复习版数据结构与算法 文章标签： 算法 python c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52711790/article/details/127928596
版权

目录

一、前言

二、题一：二叉树的最近公共祖先

1、上链接

2、基本思路

（1）朴素法

（2）LCA倍增法。

3、朴素法代码

（1）C++（AC）

（2）python（29/31，时间超限了但算法正确性是可以保证的）

4、LCA倍增法

（1）C++（不提交，因为不想补全力扣给的入口函数，但是能保证算法正确性）

5、其他递归法

三、题二：【模板】最近公共祖先（LCA）

1、上链接

2、基本思路

3、倍增法代码

（1）C++ （AC）

（2）python（70分）

一、前言

又是一个复习的算法题目，下面直接看题吧。

二、题一：二叉树的最近公共祖先

1、上链接

236. 二叉树的最近公共祖先 - 力扣（Leetcode）

2、基本思路

有两种方法可解。

（1）朴素法

假设给定两个节点p，q，那么我们应该找出两条路径并存起来，路径是从根节点到给定节点，怎么找呢？利用栈进行递归查找即可。

（2）LCA倍增法。

为什么倍增法可行，因为一个整型数永远可以化成一个二进制数（二进制转十进制）。

3、朴素法代码

（1）C++（AC）

顺便也复习了一下怎么建树。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

///**
// * Definition for a binary tree node.
// */
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
	int* nums;
public:
	Solution(){
		nums=new int[11];
		int n[]={3,5,1,6,2,0,8,-1,-1,7,4};
		for(int i=0;i<11;++i)
			nums[i]=n[i];

//		for(int i=0;i<11;++i)
//			cout<<nums[i]<<" ";
//		cout<<endl;
	}

	void display(TreeNode* node){
		if(node){
			display(node->left);
			cout<<node->val<<endl;
			display(node->right);
		}
	}

	TreeNode* createTree(int idx){
		if(idx>10)
			return NULL;
		//cout<<idx<<endl;
		int num=nums[idx];
		TreeNode* t;
		if(num==-1){
			t = NULL;
		}else{
			t=new TreeNode(num);
			t->left=createTree(2*idx+1);
			t->right=createTree(2*idx+2);
		}
		return t;
	}

	void dfs_search(TreeNode* node,TreeNode* target,vector<TreeNode *> &stack,vector<TreeNode*> &path){
		if(node==NULL)
			return;
		stack.push_back(node);
//        cout<<node->val<<endl;
		if(node->val==target->val){
//			path=stack;
			path.assign(stack.begin(),stack.end());
			return;
		}
//        cout<<"2"<<endl;
		dfs_search(node->left,target,stack,path);
		dfs_search(node->right,target,stack,path);
		stack.pop_back();
	}

	//朴素法  用时击败16.68%，内存击败7.59%
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode *> p_path;
        vector<TreeNode *> q_path;
        vector<TreeNode *> stack;

        dfs_search(root,p,stack,p_path);
        stack.clear();
        dfs_search(root,q,stack,q_path);
//
//        for(int i=0;i<p_path.size();++i)
//            cout<<p_path[i]->val<<" ";
//        cout<<endl;
//        for(int i=0;i<q_path.size();++i)
//            cout<<q_path[i]->val<<" ";
//        cout<<endl;

        TreeNode* common;
        int i=0;
        while(i<p_path.size() && i<q_path.size()){
        	if(p_path[i]==q_path[i]){
        		common=p_path[i];
			}
			i++;
		}
		return common;
    }
};

int main(){
	Solution Tree;
	TreeNode* root=Tree.createTree(0);
//	Tree.display(root);
	int p,q;
	cin>>p>>q;
	TreeNode* pp=new TreeNode(p);
	TreeNode* qq=new TreeNode(q);

	TreeNode* ans=Tree.lowestCommonAncestor(root,pp,qq);
	cout<<ans->val<<endl;

	return 0;
}

（2）python（29/31，时间超限了但算法正确性是可以保证的）

import copy

class TreeNode():   # python 没有结构体，但可以用类实现相同效果
    def __init__(self,val:int,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right

def Create_Tree(node,vals,idx):
    if idx>10:
        return node
    if vals[idx]=='#':
        node=None
    else:
        node=TreeNode(int(vals[idx]))
        node.left=Create_Tree(node.left,vals,2*idx+1)  
        node.right=Create_Tree(node.right,vals,2*idx+2)
    return node

def display(root):
    if root:
        display(root.left)
        print(root.val)
        display(root.right)

class Solution:
    def __init__(self):
        self.p_path=[]
        self.q_path=[]
        self.stack=[]

    def dfs_search(self,node:'TreeNode',target:'TreeNode',flg):
        if node==None:
            return
        self.stack.append(node)
        if node.val == target.val:
            if flg==0:
                self.p_path=copy.deepcopy(self.stack)
            else:
                self.q_path=copy.deepcopy(self.stack)
            return
        self.dfs_search(node.left,target,flg)
        self.dfs_search(node.right,target,flg)
        self.stack.pop()
    
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        self.dfs_search(root,p,0)
        self.stack.clear()
        self.dfs_search(root,q,1)

        common=TreeNode(None);
        i=0
        while i<len(self.p_path) and i<len(self.q_path):
            if self.p_path[i].val==self.q_path[i].val:
                common=copy.deepcopy(self.p_path[i])
            i+=1
        return common

   
if __name__=='__main__':
    node=None
    vals=list("3516208##74")
    root=Create_Tree(node,vals,0)
##    display(root)
    n1,n2=map(int,input().split())
    p=TreeNode(n1)
    q=TreeNode(n2)

    sol=Solution()
    ans=sol.lowestCommonAncestor(root,p,q)
    print(ans.val)

4、LCA倍增法

（1）C++（不提交，因为不想补全力扣给的入口函数，但是能保证算法正确性）

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const int N=10010;
int n,m,cnt=1;
struct Edge{
	int to,w,next;
}edge[N];
int head[N],dep[N],fa[N][N];

void Add(int u,int v){
	edge[cnt].to=v;
	edge[cnt].next=head[u];
//	edge[cnt].w=w;
	head[u]=cnt;
//	cout<<"对于"<<u<<" "<<v<<"这条边"<<cnt<<" "<<edge[cnt].next<<" "<<edge[cnt].to<<" "<<head[u]<<endl;
	cnt++;
}

//int k=0; 
void dfs(int v,int father){  //填深度表和跳步表 
	dep[v]=dep[father]+1;
	fa[v][0]=father;
	for(int i=1;i<=19;++i)
		fa[v][i]=fa[fa[v][i-1]][i-1];
	
	for(int i=head[v];i;i=edge[i].next){
		int p=edge[i].to;
//		cout<<k<<" "<<i<<" "<<p<<endl;
//		k++;
		if(p!=father)
			dfs(p,v);	
	}
}

int lca(int x,int y){
//	cout<<dep[0]<<" "<<dep[x]<<" "<<dep[y]<<endl;
	if(dep[x]<dep[y])
		swap(x,y);
	for(int i=19;i>=0;i--)   //先跳到同一层 
		if(dep[fa[x][i]]>=dep[y]){
			x=fa[x][i];
//			cout<<"* "<<fa[x][i]<<endl;
		}
			
//	cout<<"11"<<endl;
	if(x==y)
		return y;
//	cout<<"22"<<endl;
	for(int i=19;i>=0;i--){  //再跳到lca的下一层 
		if(fa[x][i]!=fa[y][i]){
			x=fa[x][i],y=fa[y][i];
		}		
	}
	return fa[x][0];
}


struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Tree{
public:
	int nums[11] = {3,5,1,6,2,9,8,-1,-1,7,4};  //因为样例中有一个节点的值为0，导致dep[0]被更改了，所以调试了很久，这个样例我把0换成了9 
//	int nums[2]={1,2};
	TreeNode* createTree(int idx){
		if(idx>10)
			return NULL;
		TreeNode* t;
		if(nums[idx]==-1){
			t=NULL;
			return t;
		}else{
			t=new TreeNode(nums[idx]);
			t->left= createTree(2*idx+1);
			t->right=createTree(2*idx+2);
		}
		return t;
	}
	void display(TreeNode* node){
		if(node){
			display(node->left);
			cout<<node->val<<endl;
			display(node->right);
		}
	}
	void add_edge(TreeNode* node){ //链式前向星加边，当然也可以根据数组下标加边，这里建树再加边的操作略显复杂 
		if(node->left!=NULL){
			Add(node->val,node->left->val);
			Add(node->left->val,node->val);
			add_edge(node->left);
		}
		if(node->right!=NULL){
			Add(node->val,node->right->val);
			Add(node->right->val,node->val);
			add_edge(node->right);
		}	
	}		
};


int main(){
	Tree* t=new Tree();
	TreeNode* root=t->createTree(0);
//	t->display(root);
	t->add_edge(root);
//	cout<<root->val<<endl;
//	cout<<"dep[0]: "<<dep[0]<<endl;
	dfs(root->val,0);
	int x,y;
	cin>>x>>y;
	int ans=lca(x,y);
	cout<<ans<<endl;
	
	return 0;
}

5、其他递归法

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL)
            return NULL;
        if(root == p || root == q) 
            return root;
            
        TreeNode* left =  lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
       
        if(left == NULL)
            return right;
        if(right == NULL)
            return left;      
        if(left && right) // p和q在两侧
            return root;
        
        return NULL; // 必须有返回值
    }
};

三、题二：【模板】最近公共祖先（LCA）

1、上链接

P3379 【模板】最近公共祖先（LCA） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

2、基本思路

为倍增法量身定做的一道题，下面用链式前向星+倍增法搞定。

3、倍增法代码

（1）C++ （AC）

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

int n,m,s; //树的结点个数、询问次数、树根节点的序号 
int x,y; //x和y之间有一条直接连接的边 
int a,b; //表示询问a和b的最近公共祖先 

const int N=5000100;
int cnt=1,head[N];
struct Edge{
	int to,next;
} e[N];

int dep[N],fa[N][22];

void Add(int x,int y){
	e[cnt].to=y;
	e[cnt].next=head[x];
	head[x]=cnt++;
}

void dfs(int u,int father){  //填深度表和跳步表 
	dep[u]=dep[father]+1; 
	fa[u][0]=father;
	for(int i=1;i<=19;++i)
		fa[u][i]=fa[fa[u][i-1]][i-1];
	
	for(int i=head[u];i;i=e[i].next){
		int p=e[i].to;
		if(p!=father)
			dfs(p,u);
	}
}

int lca(int x,int y){
	if(dep[x]<dep[y])
		swap(x,y);
	for(int i=19;i>=0;i--)    //跳到同一层 
		if(dep[fa[x][i]]>=dep[y])
			x=fa[x][i];
			
	if(x==y)
		return y;
	
	for(int i=19;i>=0;i--)
		if(fa[x][i]!=fa[y][i])
			x=fa[x][i],y=fa[y][i];
	
	return fa[x][0];
	
}

int main(){
	cin>>n>>m>>s;
	for(int i=0;i<n-1;++i){
		cin>>x>>y;
		Add(x,y);
		Add(y,x);
	} 
	dfs(s,0);
//	cout<<lca(4,5)<<endl; 
	for(int i=0;i<m;i++){
		cin>>a>>b;
		cout<<lca(a,b)<<endl; 
	}
	return 0;
}

（2）python（70分）

N=500010
# 没办法，N=5000010会全部时间超限
cnt=1
head=[0]*N
next=[0]*N
to=[0]*N

dep=[0]*N
fa=[[0]*20 for _ in range(N)]

def Add(a,b):
    global cnt
    to[cnt]=b
    next[cnt]=head[a]
    head[a]=cnt
    cnt+=1

def dfs(u:int,father:int):   # 填深度表和跳步表
    dep[u]=dep[father]+1
    fa[u][0]=father
    for i in range(1,20):
        fa[u][i]=fa[fa[u][i-1]][i-1]

    i=head[u]
    while i:
        p=to[i]
        if p!=father:
            dfs(p,u)
        i=next[i]
    
def lca(x,y)->int:
    if dep[x]<dep[y]:
        x,y=y,x
    for i in range(19,-1,-1):    # 先跳到同一层
        if dep[fa[x][i]]>=dep[y]:
            x=fa[x][i]
    if x==y:
        return y
    for i in range(19,-1,-1):
        if fa[x][i]!=fa[y][i]:
            x,y=fa[x][i],fa[y][i]
    return fa[x][0]

n,m,s=map(int,input().split())
for i in range(n-1):
    x,y=map(int,input().split())
    Add(x,y)
    Add(y,x)
dfs(s,0)
for i in range(m):
    a,b=map(int,input().split())
    print(lca(a,b))

以上，最近公共祖先

祝好

吕飞雨的头发不能秃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言递归法快速排序.c
01-21
C语言初学者
二叉树最近最近公共祖先
05-15
Java语言，通过栈的方法建立二叉树，递归求最近共同祖先结点
【leetcode/二叉树】二叉树的最近公共祖先（递归+找节点路径）
qq_43338695的博客
10-19 698
问题描述： 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root =[3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入:...
Java LeetCode 236. 二叉树的最近公共祖先（递归）
Naion的博客
05-28 494
做一些二叉树的题目，进一步理解递归。
「leetcode」235. 二叉搜索树的最近公共祖先:【递归】【迭代】详解
代码随想录
10-23 367
二叉搜索树的最近公共祖先问题如约而至
leetcode 236. 二叉树的最近公共祖先 递归解法 c语言
fuyuande的博客
10-30 1726
如题： 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x， 满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root =[3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root...
LeetCode 235. 二叉搜索树的最近公共祖先 (递归)
Amxrjgcs的博客
05-04 266
思路 利用二叉搜索树的性质，左子树中的值都小于根节点，右子树中的值都大于根节点； 根据题意要找到公共父节点，也就是说，p和q在一个节点的两端，即一个大于根节点，一个小于根节点 所以可以使用递归的方式，如果p和q同时小于或者大于根节点，就去他的对应的左子树(同时小于都在左子树中)和右子树(同时大于都在右子树中)中寻找。 直到找到不同时大于或者小于的根节点，就是他们的最近公共父节点(第一次遇到这样的节点，一定是最近的) 代码实现 /** * Definition for a binary tree no.
二叉树的最近公共祖先——递归/深度优先搜索
weixin_45594172的博客
10-03 621
二叉树的最近公共祖先——递归/深度优先搜索
【数据结构】二叉树篇|超清晰图解和详解：二叉树的最近公共祖先
Yaoyao2024的博客
08-14 3306
首先要明白，当root为p,q的最近祖先节点，只有下面3种情况： 1. p，q在root分别存在于root的左右子树中（异侧）——>root即为最近祖先节点 2. p, q均在root的左侧——>p/q即为最近祖先节点 3. p, q均在root的右侧——>同理
java 二叉树_LeetCode刷题记录(Java)——236二叉树的最近公共祖先
weixin_39715348的博客
11-24 119
/** * LeetCode 236 * 题意： * 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 * 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q， * 最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” * 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,nu...
java递归法求字符串逆序
09-03
主要介绍了java递归法求字符串逆序,涉及java递归调用的相关操作技巧,需要的朋友可以参考下
python递归法解决棋盘分割问题
09-19
主要为大家详细介绍了python递归法解决棋盘分割问题，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
实验二　用递归下降法分析表达式实验
02-08
1.掌握用递归下降分析法进行语法分析的方法。加深对自顶向下语法分析原理的理解。 2.掌握设计、编制并调试自顶向下语法分析程序的思想和方法。 3.本实验是高级语言程序设计、数据结构和编译原理中词法分析、自顶向下...
236. 二叉树的最近公共祖先 Python
小明
09-19 256
的基础上将二叉搜索树改为二叉树，那么根据我们之前搜索p,q节点的所有父节点的思路来看，搜索方式有所不同，不能通过二叉搜索树的规律来快速找到对应p,q节点，但也可以通过一步一步试错的方式慢慢找到所有的父节点，解题思路同。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大**（一个节点也可以是它自己的祖先）**。给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
LeetCode 题解 | 236. 二叉树的最近公共祖先（经典递归 C++）
捡起一束光的博客
02-12 446
题目描述（中等难度） 原题链接 算法 (递归) O(n)O(n)O(n) 当我们用递归去做这个题时不要被题目误导，应该要明确一点 这个函数的功能有三个：给定两个节点p和q 如果p和q都存在，则返回它们的公共祖先； 如果只存在一个，则返回存在的一个； 如果p和q都不存在，则返回NULL 题目说给定的两个节点都存在，那自然还是能用上面的函数来解决 具体思路： 如果当前结点root等于NULL...
最近公共祖先 python_在二叉树中找到两个节点的最近公共祖先
weixin_34952628的博客
02-05 255
#classTreeNode:#def__init__(self,x):#self.val=x#self.left=None#self.right=None###@paramrootTreeNode类#@paramo1int整型#@paramo2int整型#@returnint整型#class...
【数据结构】（二叉树）求二叉树中两个节点的最近公共祖先节点 递归&&非递归
热门推荐
你好丶下一秒
08-02 1万+
递归
倍增？最近公共祖先？——从定义到实现，帮你一步步吃掉它！
fnmdpnmsl的博客
04-11 777
​​那么我们在下一个知识点再见啦！拜拜！
Java 7大排序
最新发布
m0_74270127的博客
05-10 705
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
二叉树最近公共祖先dfs非递归
08-17
非递归实现DFS可以通过使用栈来模拟递归的过程。...注意：上述代码中的 `lowestCommonAncestor` 函数是调用 `findPath` 函数来获取两个目标节点的路径，并比较路径的公共部分来找到最近公共祖先的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吕飞雨的头发不能秃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值