【深度优先搜索】【树】【C++算法】2003. 每棵子树内缺失的最小基因值

最新推荐文章于 2024-05-15 18:29:40 发布
最新推荐文章于 2024-05-15 18:29:40 发布
阅读量1.8k 收藏 39
点赞数 46
分类专栏： 数据结构与算法 文章标签： 算法 深度优先 c++ LeetCode 树 图论 基因值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/136164048
版权

作者推荐

动态规划的时间复杂度优化

本文涉及知识点

深度优先搜索

LeetCode2003. 每棵子树内缺失的最小基因值

有一棵根节点为 0 的 家族树 ，总共包含 n 个节点，节点编号为 0 到 n - 1 。给你一个下标从 0 开始的整数数组 parents ，其中 parents[i] 是节点 i 的父节点。由于节点 0 是 根 ，所以 parents[0] == -1 。
总共有 105 个基因值，每个基因值都用 闭区间 [1, 105] 中的一个整数表示。给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 是节点 i 的基因值，且基因值 互不相同 。
请你返回一个数组 ans ，长度为 n ，其中 ans[i] 是以节点 i 为根的子树内 缺失 的 最小 基因值。
节点 x 为根的 子树 包含节点 x 和它所有的 后代 节点。
示例 1：
在这里插入图片描述

输入：parents = [-1,0,0,2], nums = [1,2,3,4]
输出：[5,1,1,1]
解释：每个子树答案计算结果如下：

  • 0：子树包含节点 [0,1,2,3] ，基因值分别为 [1,2,3,4] 。5 是缺失的最小基因值。
  • 1：子树只包含节点 1 ，基因值为 2 。1 是缺失的最小基因值。
  • 2：子树包含节点 [2,3] ，基因值分别为 [3,4] 。1 是缺失的最小基因值。
  • 3：子树只包含节点 3 ，基因值为 4 。1是缺失的最小基因值。
    示例 2：
    在这里插入图片描述

输入：parents = [-1,0,1,0,3,3], nums = [5,4,6,2,1,3]
输出：[7,1,1,4,2,1]
解释：每个子树答案计算结果如下：

  • 0：子树内包含节点 [0,1,2,3,4,5] ，基因值分别为 [5,4,6,2,1,3] 。7 是缺失的最小基因值。
  • 1：子树内包含节点 [1,2] ，基因值分别为 [4,6] 。 1 是缺失的最小基因值。
  • 2：子树内只包含节点 2 ，基因值为 6 。1 是缺失的最小基因值。
  • 3：子树内包含节点 [3,4,5] ，基因值分别为 [2,1,3] 。4 是缺失的最小基因值。
  • 4：子树内只包含节点 4 ，基因值为 1 。2 是缺失的最小基因值。
  • 5：子树内只包含节点 5 ，基因值为 3 。1 是缺失的最小基因值。
    示例 3：

输入：parents = [-1,2,3,0,2,4,1], nums = [2,3,4,5,6,7,8]
输出：[1,1,1,1,1,1,1]
解释：所有子树都缺失基因值 1 。

提示：
n == parents.length == nums.length
2 <= n <= 105
对于 i != 0 ，满足 0 <= parents[i] <= n - 1
parents[0] == -1
parents 表示一棵合法的树。
1 <= nums[i] <= 105
nums[i] 互不相同。

深度优先搜索

除了基因1的节点及它的祖先，其它节点都缺少1。
DFS(cur)结束时，处理了且只处理了它哥哥及自己的后代，如果我们将基因1及其祖先调整成长子。可以将空间复杂从O(nlogn)降低到O(n)。
注意：如果不优化，空间复杂度是O(nn)，就是直接为每个节点分配空间，复制所有的后代。极端情况下，独子树的空间复杂度是O(nn)。直接用子树的空间，独子树空间复杂度O(n)；非独子树O(nlong)。

超时代码

class CParentToNeiBo
{
public:
	CParentToNeiBo(const vector<int>& parents)
	{
		m_vNeiBo.resize(parents.size());
		for (int i = 0; i < parents.size(); i++)
		{
			if (-1 == parents[i])
			{
				m_root = i;
			}
			else
			{
				m_vNeiBo[parents[i]].emplace_back(i);
			}
		}
	}
	vector<vector<int>> m_vNeiBo;
	int m_root=-1;
};

class Solution {
public:
	vector<int> smallestMissingValueSubtree(vector<int>& parents, vector<int>& nums) {
		CParentToNeiBo neiBo(parents);
		m_nums = nums;
		m_vIs1.resize(nums.size());
		m_ans.assign(nums.size(),1);
		m_vHas.resize(100'000+10);
		DFS1(neiBo.m_root, neiBo.m_vNeiBo);
		for (auto& v : neiBo.m_vNeiBo)
		{
			for (int j = 1; j < v.size(); j++)
			{
				if (m_vIs1[v[j]])
				{
					std::swap(v[0], v[j]);
				}
			}
		}
		DFS2(neiBo.m_root, neiBo.m_vNeiBo);
		return m_ans;
	}
	void DFS2(int cur, vector<vector<int>>& neiBo)
	{		
		for (const auto& next : neiBo[cur])
		{
			DFS2(next, neiBo);
		}
		m_vHas[m_nums[cur]] = true;
		while (m_vHas[m_iNeed])
		{
			m_iNeed++;
		}
		if (m_vIs1[cur])
		{
			m_ans[cur] = m_iNeed;
		}
	}
	bool DFS1(int cur, vector<vector<int>>& neiBo)
	{
		bool b = (1 == m_nums[cur]);		
		for (const auto& next : neiBo[cur])
		{
			b |= DFS1(next, neiBo);
		}
		return m_vIs1[cur]=b;
	}
	vector<int> m_nums,m_ans;
	vector<bool> m_vIs1;
	int m_iNeed = 1;
	vector<bool> m_vHas;
};

1及其祖先不用DFS

class CParentToNeiBo
{
public:
	CParentToNeiBo(const vector<int>& parents)
	{
		m_vNeiBo.resize(parents.size());
		for (int i = 0; i < parents.size(); i++)
		{
			if (-1 == parents[i])
			{
				m_root = i;
			}
			else
			{
				m_vNeiBo[parents[i]].emplace_back(i);
			}
		}
	}
	vector<vector<int>> m_vNeiBo;
	int m_root=-1;
};

class Solution {
public:
	vector<int> smallestMissingValueSubtree(vector<int>& parents, vector<int>& nums) {
		CParentToNeiBo neiBo(parents);
		m_nums = nums;
		m_vIs1.resize(nums.size());
		m_ans.assign(nums.size(),1);
		m_vHas.resize(100'000+10);
		int i1 = std::find(nums.begin(), nums.end(), 1)- nums.begin();
		while ((-1 != i1) && (nums.size() != i1))
		{
			m_vIs1[i1] = true;
			i1 = parents[i1];
		}
		for (auto& v : neiBo.m_vNeiBo)
		{
			for (int j = 1; j < v.size(); j++)
			{
				if (m_vIs1[v[j]])
				{
					std::swap(v[0], v[j]);
				}
			}
		}
		DFS2(neiBo.m_root, neiBo.m_vNeiBo);
		return m_ans;
	}
	void DFS2(int cur, vector<vector<int>>& neiBo)
	{		
		for (const auto& next : neiBo[cur])
		{
			DFS2(next, neiBo);
		}
		m_vHas[m_nums[cur]] = true;		
		if (m_vIs1[cur])
		{
            while (m_vHas[m_iNeed])
		{
			m_iNeed++;
		}
			m_ans[cur] = m_iNeed;
		}
	}
	vector<int> m_nums,m_ans;
	vector<bool> m_vIs1;
	int m_iNeed = 1;
	vector<bool> m_vHas;
};

测试用例


template<class T,class T2>
void Assert(const T& t1, const T2& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}

}

int main()
{
	vector<int> parents,  nums;
	{
		Solution sln;
		parents = { -1, 0, 0, 2 }, nums = { 1, 2, 3, 4 };
		auto res = sln.smallestMissingValueSubtree(parents, nums);
		Assert({ 5,1,1,1 }, res);
	}
	
	{
		Solution sln;
		parents = { -1, 0, 1, 0, 3, 3 }, nums = { 5, 4, 6, 2, 1, 3 };
		auto res = sln.smallestMissingValueSubtree(parents, nums);
		Assert({ 7,1,1,4,2,1 }, res);
	}

	{
		Solution sln;
		parents = { -1, 2, 3, 0, 2, 4, 1 }, nums = { 2, 3, 4, 5, 6, 7, 8 };
		auto res = sln.smallestMissingValueSubtree(parents, nums);
		Assert({ 1,1,1,1,1,1,1 }, res);
	}
}

2023年2月版（当时能过）

class Solution {
public:
vector smallestMissingValueSubtree(const vector& parents, const vector& nums) {
m_c = nums.size();
m_vDirect.resize(m_c);
for (int i = 1; i < parents.size(); i++)
{
m_vDirect[parents[i]].push_back(i);
}
m_vVisiteValue.resize(m_c + 1);
m_vRet.assign(m_c, 1);
for (int i = 0; i < nums.size(); i++)
{
if (1 == nums[i])
{
DFS(i, -1,parents, nums);
break;
}
}
return m_vRet;
}
void DFS(int iCur, int iFromChild,const vector& parents, const vector& nums)
{
if (-1 == iCur)
{
return;
}
DFSForValue(iCur, iFromChild, nums);
int iMiss = (-1 == iFromChild) ? 1 : m_vRet[iFromChild];
while ((iMiss < m_vVisiteValue.size()) && (m_vVisiteValue[iMiss]))
{
iMiss++;
}
m_vRet[iCur] = iMiss;
DFS(parents[iCur], iCur, parents, nums);
}
void DFSForValue(int iCur, int iFromChild, const vector& nums)
{
m_vVisiteValue[nums[iCur]] = true;
for (auto& next : m_vDirect[iCur])
{
if (next == iFromChild)
{
continue;
}
DFSForValue(next, iFromChild, nums);
}
}
int m_c;
vector<vector> m_vDirect;
vector m_vRet;
vector m_vVisiteValue;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

闻缺陷则喜何志丹
关注
  • 46
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++图的优先算法和最小生成树_数据结构与算法实验四_艾孜尔江·艾尔斯兰著.zip
01-01
本实验资源内附详细的指导教程和演示案例，通俗易懂，由艾孜尔江·艾尔斯兰亲自实验并撰著而成，均为底层开发，可供研究和学习使用，平时工作中亦可实践，是初学者深入学习数据结构与算法的法宝，基于C++语言实现，...
最小生成树C++源码.zip
12-18
最小生成树最小生成树C++源码.zip最小生成树C++源码.zip最小生成树C++源码.zip
遗传编程（GA，genetic programming）算法初探，以及用遗传编程自动生成符合题解的正则表达式的实践...
weixin_30735391的博客
09-25 2087
1. 遗传编程简介 0x1：什么是遗传编程算法，和传统机器学习算法有什么区别 传统上，我们接触的机器学习算法，都是被设计为解决某一个某一类问题的确定性算法。对于这些机器学习算法来说，唯一的灵活性体现在参数搜索空间上，向算法输入样本，算法借助不同的优化手段，对参数进行调整，以此来得到一个对训练样本和测试样本的最佳适配参数组。 遗传编程算法完全走了另一外一条路，遗传编程算法的目标是编写...
图论知识汇总
闻缺陷则喜何志丹
04-11 1274
深度优先 广度优先
深度学习基础知识整理
h
11-24 9455
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/kwame211/article/details/81165381 本文是在七月的BAT机器学习面试1000题系列进行修改。&nbsp; 前言 &nbsp; &nbsp...
字节校园精选 66 道高频经典笔面试题（含多种思路）（下）
码农研究僧的博客
09-21 2053
第一版本的链接如下： 字节校园精选 66 道高频经典笔面试题（含多种思路）（上） 以下为我的学习笔记以及汇总，也为了方便其他人更加快速的浏览
每日一题 2023.10.31
blueoni的博客
10-31 28
C++代码：需要注意的是从下往上走,DFS算法。
BAT机器学习面试1000题系列（第1~305题）
热门推荐
结构之法 算法之道
09-28 50万+
BAT机器学习面试1000题系列 整理：July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络，取之分享，用之分享，且在撰写答案过程中若引用他人解析则必注明原作者及来源链接。另，不少答案得到寒小阳、管博士、张雨石、王赟、褚博士等七月在线名师审校。 说明：本系列作为国内首个AI题库，首发于七月在线实验室公众号上：julyedulab，并部分更新...
【艾琪出品】《计算机应用基础》【试题汇总2】
加油
09-01 1万+
自备留用 《Java语言程序设计》20春期末考核 1. 接口体中不应包含( )。 A 常量定义 B 常量赋值 C 方法实现 D 方法声明 2. 以下( )不是Java的关键字。 A FALSE B const C this D void 3. 以下关于继承的叙述正确的是（）。 A 在Java中类只允许单一继承 B 在Java中一个类只能实现一个接口 C 在Java中一个类不能同时继承一个类和实现一个接口 D 在Java中接口只允许单一继承 4. 编译并且执行以下代码,会出现什么情况...
数据分析真题日刷 | 京东2019校招数据分析工程师笔试题
是圣洁呀✨
07-05 3万+
今日真题 网易2018校园招聘数据分析工程师笔试卷（来源：牛客网） 题型 客观题：单选51道,不定项选择12道 完成时间 120分钟 牛客网评估难度系数 3颗星 1. 在软件开发过程中，我们可以采用不同的过程模型，下列有关 增量模型描述正确的是（） A. 是一种线性开发模型，具有不可回溯性 B. 把待开发的软件系统模块化，将每个模块作为一个增量组件，从而分批次地分析、设计、编码和测试这些增量...
BAT机器学习面试1000题系列（第1~305题
小爽哒哒哒的博客
09-29 1万+
1 请简要介绍下SVM，机器学习 ML模型 易SVM，全称是support vector machine，中文名叫支持向量机。SVM是一个面向数据的分类算法，它的目标是为确定一个分类超平面，从而将不同的数据分隔开。 扩展：这里有篇文章详尽介绍了SVM的原理、推导，《支持向量机通俗导论（理解SVM的三层境界）》。此外，这里有个视频也是关于SVM的推导：《纯白板手推SVM》   2 请简要介绍下t...
动态优先数高者优先进程调度算法C++源码.zip
11-03
按优先数进程调度算法 动态优先数高者优先进程调度算法C++源码.zip 动态优先数高者优先进程调度算法C++源码.zip
图的最小生成树Prim算法C++面向对象实现.doc
05-30
一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。
Java 7大排序
m0_74270127的博客
05-10 804
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
[Easy] leetcode-35 搜索插入位置
Sofine
05-09 251
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
从零学算法6
m0_53256503的博客
05-11 990
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。输入：s = “PAYPALISHIRING”, numRows = 3。输入：s = “PAYPALISHIRING”, numRows = 4。输入：s = “A”, numRows = 1。输出：“PAHNAPLSIIGYIR”输出：“PINALSIGYAHRPI”
AtCoder Beginner Contest 353
2301_78527293的博客
05-11 998
abc
算法练习第22天|39. 组合总和、40.组合总和II
最新发布
Brillian123的博客
05-15 589
39. 组合总和39. 组合总和 - 力扣（LeetCode）
深度优先搜索算法c++
07-27
深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。以下是一个基于C++的深度优先搜索算法示例： ```cpp #include <iostream> #include <vector> using namespace std; // 定义图的邻接表表示 class Graph { int numVertices; // 图中顶点的数量 vector<vector<int>> adjLists; // 邻接表 public: Graph(int vertices) { numVertices = vertices; adjLists.resize(numVertices); } // 添加边 void addEdge(int src, int dest) { adjLists[src].push_back(dest); adjLists[dest].push_back(src); } // 深度优先搜索递归函数 void DFSUtil(int vertex, vector<bool>& visited) { visited[vertex] = true; cout << vertex << " "; // 对邻接顶点进行递归调用 for (int adjVertex : adjLists[vertex]) { if (!visited[adjVertex]) { DFSUtil(adjVertex, visited); } } } // 深度优先搜索 void DFS(int startVertex) { vector<bool> visited(numVertices, false); // 记录顶点是否访问过 DFSUtil(startVertex, visited); } }; int main() { Graph g(6); // 创建一个有6个顶点的图 // 添加边 g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 3); g.addEdge(1, 4); g.addEdge(2, 4); g.addEdge(3, 4); g.addEdge(3, 5); cout << "深度优先搜索结果: "; g.DFS(0); return 0; } ``` 以上代码实现了一个简单的无向图，并使用深度优先搜索算法遍历图中的顶点。输出结果为从起始顶点开始的深度优先搜索顺序。你可以根据需要修改图的大小和边的连接关系。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

闻缺陷则喜何志丹

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

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

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

打赏作者

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

抵扣说明：

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

余额充值