0031树节点的第k个祖先

最新推荐文章于 2022-11-13 11:00:16 发布

「已注销」

最新推荐文章于 2022-11-13 11:00:16 发布

阅读量517

点赞数

分类专栏：每天一道算法题文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/leadingfigure/article/details/106876524

版权

每天一道算法题专栏收录该内容

30 篇文章

订阅专栏

这是一篇关于如何在给定的树结构中找到一个节点的第k个祖先的算法解析。文章介绍了两种方法：暴力法和二分查找法。暴力法通过递归实现，时间复杂度为O(n)，而二分查找法利用动态规划优化，时间复杂度降低到O(log n)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树节点的第k个祖先

编号：0031

试题来源：leetcode

my blog:Something

试题描述

给定一棵树，树上有n个节点，按照从0到n-1进行编号。树以父节点数组的形式给出，其中parent[i]是节点i的父节点。树的根节点是编号为0的节点。其中parent[0]=-1表示其没有父节点。

请设计并实现getKthAncestor(int node, int k)函数，返回值为节点node的第k个祖先节点。若不存在，则返回-1。

树节点的第k个祖先节点是从该节点到根节点路径上的第k个节点。

限制：

$1\leq k\leq n\leq 5*10^4$
parent[0]==-1表示编号为0的节点是根节点
对于所有的 $0 < i < n$ ， $0\leq parent[i] <n$ 总成立
$0\leq node<n$
至多查询 $5*10^4$ 次

解答算法

暴力法

算法思路

很显然，最简单的方法就是进行递归调用getKthAncestor函数，我们要查找node的第k个父节点，也就是找node的父节点的第k-1个父节点，也就是调用getKthAncestor(parent[node],k-1)。

递归调用的终止条件要么是k==0，说明当前节点就是返回值，要么是parent[node]==-1,说明查询不到满足条件的，返回-1。

代码实现

class TreeAncestor {
private:
	int size;
	vector<int> parent;

public:
    TreeAncestor(int n, vector<int>& parent) {
    	size = n;
    	this->parent = parent;
    }
    
    int getKthAncestor(int node, int k) {  //递归调用
    	if(k == 0)
    	{
    		return node;
    	}
    	if(node == 0)
    	{
    		return -1;
    	}
    	return getKthAncestor(parent[node], k - 1);
    }
};

复杂度分析

时间复杂度：最坏情况下，要遍历整个深度，因此时间复杂度为 $O (n)$
空间复杂度：递归调用要使用栈空间，栈空间占用也为 $O (n)$

二分查找

算法思路

利用动态规划的思路，建立一个辅助的二维数组dp，其中dp[0][i]存放的是节点i的第 $2^0$ 个父节点，也即parent[i]。

显然dp[i][j]的定义为节点j的第 $2^i$ 个父节点，因此显然递推公式有
$d p [i] [j] = d p [i - 1] [d p [i - 1] [j]]$
然后就可以利用这个对我们要查找的第k个祖先节点进行拆分，将其划分成二进制数，然后依次进行寻找，例如我们要找寻第3个父节点，也就是使用dp[dp[i][1]][0]。

代码实现

class TreeAncestor {
private:
	int n;
	int size;
	vector<vector<int>> dp;

public:
    TreeAncestor(int n, vector<int>& parent) {
    	int flag = 1;
    	this->n = n;
    	int i = 0;
    	dp.push_back(parent);
    	while(flag)
    	{
    		flag = 0;
    		vector<int> tmp(n);
    		for(int j = 0; j < n; ++j)
    		{
    			if(dp[i][j] != -1)
    			{
    				tmp[j] = dp[i][dp[i][j]];
    			}
    			else
    			{
    				tmp[j] = -1;
    			}
    			if(tmp[j] != -1)
    			{
    				flag = 1;
    			}
    		}
    		dp.push_back(tmp);
    		++i;
    	}
    	size = dp.size();
    }
    
    int getKthAncestor(int node, int k) {
    	int i = size;
    	int result = node;
    	while(k)
    	{
    		if(k == 0)
    		{
    			return result;
    		}
    		if(k >= pow(2,i - 1))
    		{
    			result = dp[i - 1][result];
    			k -= pow(2,i - 1);
    		}
    		if(result == -1)
    		{
    			return -1;
    		}
    		--i;
    	}
    	return result;
    }
};