easyui的tree获取父节点_力扣 1519——子数中标签相同的节点数
本题主要在于对树这种数据结构的考察,以及深度优先遍历的使用,优化时可以采取空间换时间的策略。
原题
给你一棵树(即,一个连通的无环无向图),这棵树由编号从 0 到 n - 1 的 n 个节点组成,且恰好有 n - 1 条 edges 。树的根节点为节点 0 ,树上的每一个节点都有一个标签,也就是字符串 labels 中的一个小写字符(编号为 i 的 节点的标签就是 labels[i] )
边数组 edges 以 edges[i] = [ai, bi] 的形式给出,该格式表示节点 ai 和 bi 之间存在一条边。
返回一个大小为 n 的数组,其中 ans[i] 表示第 i 个节点的子树中与节点 i 标签相同的节点数。
树 T 中的子树是由 T 中的某个节点及其所有后代节点组成的树。
示例 1:
输入:n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = "abaedcd"输出:[2,1,1,1,1,1,1]解释:节点 0 的标签为 'a' ,以 'a' 为根节点的子树中,节点 2 的标签也是 'a' ,因此答案为 2 。注意树中的每个节点都是这棵子树的一部分。节点 1 的标签为 'b' ,节点 1 的子树包含节点 1、4 和 5,但是节点 4、5 的标签与节点 1 不同,故而答案为 1(即,该节点本身)。
示例 2:
输入:n = 4, edges = [[0,1],[1,2],[0,3]], labels = "bbbb"输出:[4,2,1,1]解释:节点 2 的子树中只有节点 2 ,所以答案为 1 。节点 3 的子树中只有节点 3 ,所以答案为 1 。节点 1 的子树中包含节点 1 和 2 ,标签都是 'b' ,因此答案为 2 。节点 0 的子树中包含节点 0、1、2 和 3,标签都是 'b',因此答案为 4 。
示例 3 :
输入:n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = "aabab"输出:[3,2,1,1,1]
示例 4:
输入:n = 6, edges = [[0,1],[0,2],[1,3],[3,4],[4,5]], labels = "cbabaa"输出:[1,2,1,1,2,1]
示例 5:
输入:n = 7, edges = [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]], labels = "aaabaaa"输出:[6,5,4,1,3,2,1]
提示:
- 1 <= n <= 10^5
- edges.length == n - 1
- edges[i].length == 2
- 0 <= ai, bi < n
- ai != bi
- labels.length == n
- labels 仅由小写英文字母组成
原题 url:https://leetcode-cn.com/problems/number-of-nodes-in-the-sub-tree-with-the-same-label
解题
首次尝试
这道题是要让我们计算:在子树中,和当前节点字符相同的节点个数。
那么我们就必然需要构建树中各个节点的关系,那么就需要记录父子节点的关系,因为是普通的树,一个节点的子节点可能有多个,因此我用LinkedList[] tree这样一个数组进行存储,其中tree[i]代表节点 i 的所有子节点。
至于求相同节点的个数,我想着可以从根节点 0 开始逐个遍历,先获取其第一层子节点,再根据第一层子节点逐个获取,可以采用广度优先遍历的形式。
让我们看看代码:
class Solution { public int[] countSubTrees(int n, int[][] edges, String labels) { // 构造树 LinkedList[] tree = new LinkedList[n]; for (int[] edge : edges) { // edge[0]的子节点 LinkedList child = tree[edge[0]]; if (child == null) { child = new LinkedList<>(); tree[edge[0]] = child; } // 增加子节点 child.add(edge[1]); } // 结果 int[] result = new int[n]; // 遍历并计算 for (int i = 0; i < n; i++) { // 需要遍历的字符 char cur = labels.charAt(i); // 该节点的子树中与该字符相同的节点数 int curCount = 0; // 广度优先遍历 LinkedList searchList = new LinkedList<>(); searchList.add(i); while(!searchList.isEmpty()) { int index = searchList.removeFirst(); if (cur == labels.charAt(index)) { curCount++; } // 找出该节点的子树 if (tree[index] == null) { continue; } searchList.addAll(tree[index]); } result[i] = curCount; } return result; }}
提交之后,发现有错误。错误的情况是:
输入:4[[0,2],[0,3],[1,2]]"aeed"输出:[1,2,1,1]预期:[1,1,2,1]
根据这样输入,我构造出的树是:
1 0 / 2 3
但根据预期结果反推出来的树是:
0 / 2 3 /1
那么输入中最后给出的[1,2]就不是从父节点指向子节点,也就是输入中给出的边关联的节点顺序,是任意的。
那我们的树究竟该如何构造呢?
双向记录构造树
既然我们在构造树的时候,无法直接得出父子关系,那么就将对应两个节点同时记录另一个节点。
根据题目中给出的条件:树的根节点为节点 0。这样我们在遍历的时候,就从 0 开始,只要 0 关联的节点,一定是 0 的子节点。将这些节点进行标记,这样再递归访问接下来的节点时,如果是标记过的,则说明是父节点,这样就可以明确父子节点关系了。
至于遍历的时候,因为这次我们是不知道父子节点关系的,所以无法直接采用广度优先遍历,换成深度优先遍历。
让我们看看代码:
class Solution { // 总节点数 int n; // 树 Map> tree; // 字符串 String labels; // 最终结果 int[] result; public int[] countSubTrees(int n, int[][] edges, String labels) { this.n = n; this.labels = labels; result = new int[n]; LinkedList list; // 双向构造树的关系 tree = new HashMap<>(n / 4 * 3 + 1); for (int[] edge : edges) { // 添加映射关系 list = tree.computeIfAbsent(edge[0], k -> new LinkedList<>()); list.add(edge[1]); list = tree.computeIfAbsent(edge[1], k -> new LinkedList<>()); list.add(edge[0]); } // 深度优先搜索 dfs(0); return result; } public int[] dfs(int index) { // 当前子树中,所有字符的个数 int[] charArray = new int[26]; // 开始计算,标志该节点已经计算过 result[index] = 1; // 获得其关联的节点 List nodes = tree.get(index); // 遍历 for (int node : nodes) { // 如果该节点已经访问过 if (result[node] > 0) { continue; } // 递归遍历子节点 int[] array = dfs(node); for (int i = 0; i < 26; i++) { charArray[i] += array[i]; } } // 将当前节点的值计算一下 charArray[labels.charAt(index) - 'a'] += 1; result[index] = charArray[labels.charAt(index) - 'a']; return charArray; }}
提交OK,执行用时136ms,超过36.71%,内存消耗104.5MB,超过91.38%。
时间复杂度上,应该是要研究dfs方法中的两个for循环,外层肯定是每个节点都遍历一遍,内层还需要遍历26个英文字母,也就是O(n)。
空间复杂度上,最大的应该就是存储节点映射关系的tree了,里面实际上就是 2n 个节点(因为每条边对应的两个节点都会互相存一次对方),因此也就是O(n)。
虽然过了,但执行速度很慢,可以进一步优化。
用空间换时间
针对我上面的解法,其中tree我是用的Map,虽然其get方法理论上是O(n),但毕竟涉及 hash,可以优化成数组。
至于每次取节点对应的字符所用的charAt方法,具体其实是:
public char charAt(int index) { if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }
每次都会检查一次 index,其实这完全是可以省略的,因此可以提前构造好每个位置对应的值,也用一个数组存储。
让我们看看新的代码:
class Solution { // 总节点数 int n; // 树 LinkedList[] tree; // 每个节点的值(用数字表示) int[] nodeValueArray; // 最终结果 int[] result; public int[] countSubTrees(int n, int[][] edges, String labels) { this.n = n; nodeValueArray = new int[n]; result = new int[n]; // 双向构造树的关系 tree = new LinkedList[n]; for (int i = 0; i < n; i++) { tree[i] = new LinkedList<>(); } for (int[] edge : edges) { // 添加映射关系 tree[edge[0]].add(edge[1]); tree[edge[1]].add(edge[0]); } // 生成节点的值 for (int i = 0; i < n; i++) { nodeValueArray[i] = labels.charAt(i) - 'a'; } // 深度优先搜索 dfs(0); return result; } public int[] dfs(int index) { // 当前子树中,所有字符的个数 int[] charArray = new int[26]; // 开始计算,标志该节点已经计算过 result[index] = 1; // 获得其关联的节点 List nodes = tree[index]; // 遍历 for (int node : nodes) { // 如果该节点已经访问过 if (result[node] > 0) { continue; } // 递归遍历子节点 int[] array = dfs(node); for (int i = 0; i < 26; i++) { charArray[i] += array[i]; } } // 将当前节点的值计算一下 charArray[nodeValueArray[index]] += 1; result[index] = charArray[nodeValueArray[index]]; return charArray; }}
提交之后,执行用时是96ms,内存消耗是402.2MB。看来优化的效果并不明显。
研究一下目前最优解法
这个解法真的是巧妙,执行用时20ms,超过了100%,内存消耗76.3MB,超过了100%。
我在代码中增加了注释,方便大家理解。但这样的写法,研究一下是能够看懂,但让我想估计是永远不可能想出来,可以让大家也一起学习和借鉴:
public class Solution { static class Next { Next next; Node node; Next(Next next, Node node) { this.next = next; this.node = node; } } static class Node { /** * 当前节点的index */ final int index; /** * 当前节点对应的字符值(减去'a') */ final int ci; /** * 所有关联的节点 */ Next children; /** * 该节点的父节点 */ Node parent; /** * 子树中和该节点含有相同字符的节点总个数 */ int result; /** * 是否还在队列中,可以理解为是否已访问过 */ boolean inQueue; public Node(int index, int ci) { this.index = index; this.ci = ci; this.result = 1; } /** * 从后往前,找到当前节点没有访问过的第一个子节点 */ Node popChild() { for (; ; ) { // 当前节点的所有关联节点 Next n = this.children; // 如果没有,说明子节点都遍历完了 if (n == null) { return null; } // 从后往前移除关联节点 this.children = n.next; // 返回第一个没有访问过的节点 if (!n.node.inQueue) { return n.node; } } } /** * 访问了该节点 */ Node enqueue(Node[] cnodes) { // 该节点标记为访问过 this.inQueue = true; // 记录该节点的父节点 this.parent = cnodes[ci]; // 那么现在该字符值对应的最高节点,就是当前节点。 // 这样如果之后也遇到相同字符的子节点,就可以为子节点赋值其父节点,也就是上面一行是有效的 cnodes[ci] = this; return this; } /** * 退出该节点 */ void dequeue(Node[] cnodes, int[] res) { // 之后会访问该节点的兄弟节点,因此父节点需要重新设置 cnodes[ci] = this.parent; // 设置当前节点的值 res[index] = this.result; // 父节点也可以进行累加 if (this.parent != null) { this.parent.result += this.result; } } void link(Node x) { // this节点和x节点,互相绑定 this.children = new Next(this.children, x); x.children = new Next(x.children, this); } } public int[] countSubTrees(int n, int[][] edges, String labels) { // 构造树 Node[] nodes = new Node[n]; // 每个节点对应的字符 for (int i = 0; i < n; i++) { nodes[i] = new Node(i, labels.charAt(i) - 'a'); } // 通过边的关系,将节点互相绑定 for (int[] es : edges) { nodes[es[0]].link(nodes[es[1]]); } // 最终的结果 int[] res = new int[n]; // 当前访问的节点下标 int sz = 0; // 26个小写英文字母对应的节点数组 Node[] cnodes = new Node[26]; // 下面三行可以合并成这一行: // Node node = nodes[sz++] = nodes[0].enqueue(cnodes); nodes[sz] = nodes[0].enqueue(cnodes); // 当前访问的节点 Node node = nodes[sz]; // 因为当前节点已经访问过,自然下标需要+1 sz++; for (; ; ) { // 从后往前,找到当前节点没有访问过的第一个子节点 Node child = node.popChild(); // 如果已经全部访问过了 if (child == null) { // 开始计算 node.dequeue(cnodes, res); if (--sz == 0) { break; } // 回溯到父节点 node = nodes[sz - 1]; } else { // 保证了相邻节点一定是父子节点 node = nodes[sz++] = child.enqueue(cnodes); } } return res; }}
总结
以上就是这道题目我的解答过程了,不知道大家是否理解了。本题主要在于对树这种数据结构的考察,以及深度优先遍历的使用,优化时可以采取空间换时间的策略。
有兴趣的话可以访问我的博客或者关注我的公众号、头条号,说不定会有意外的惊喜。
https://death00.github.io/
公众号:健程之道
easyui的tree获取父节点_力扣 1519——子数中标签相同的节点数相关推荐
- elementui tree获取父节点_vue_elementUI_ tree树形控件 获取选中的父节点ID
一, vue_elementUI_ tree树形控件 1.1默认点击tree节点的第一个(注意不是checked选中) :expand-on-click-node="false" ...
- elementui tree获取父节点_elementUI 树状图 点击子节点获取父节点
权限使用elementUI tree 组件,点击子节点获取对应多级的父节点 这是应用的组件 :data="hovePermissData" :default-checked- ke ...
- easyui 扩展tree 获取选中节点的级数
2019独角兽企业重金招聘Python工程师标准>>> //扩展tree, 增加getLevel方法$.extend($.fn.tree.methods, {getLevel:fun ...
- layui如何获取父节点的父节点_区块链如何运用merkle tree验证交易真实性
大部分材料都会提到区块中保存了merkle根,并且利用它作交易真实性验证.但是具体如何作这个真实性验证,没有一篇文章可以通俗的讲出来.本文假设你已经知道区块链中merkle tree的原理,现在想搞明 ...
- EasyUI中tree选中父节点自动选中子节点,取消子节点自动取消父节点,子节点勾选完毕自动勾选父节点
今天有需求,将树设为具有全选功能 选中父节点自动全选子节点 全选状态下,当用户取消某一个子节点,自动取消父节点的勾选 未全选状态下,用户勾选全部子节点,自动勾选对应的父节点 感觉挺简单,实际写的时候才 ...
- MFC动态建立二叉树、序列检错以及获取父节点
根据前序+中序或中序+后序在MFC中实现动态建立二叉树. 文章目录 根据前序+中序或中序+后序在MFC中实现动态建立二叉树. 前言 一.动态建立二叉树 1.题目要求 2.具体实现 1.对话框布局 2. ...
- layui如何获取父节点的父节点_jquery获取父元素或父节点的方法
jquery获取父元素方法比较多,比如parent(),parents(),closest()这些都能帮你实现查找父元素或节点,下面我们来一一讲解: 先举个例子, jquery获取父节点 jquery ...
- # 如何获取父节点和子节点
文章目录 一.获取父级节点 二.获取子节点 1.获取子节点 2.获取指定子节点 三.总结 一.获取父级节点 node.parentNode 代码如下(示例): <!DOCTYPE html> ...
- jquery 获取父节点 html,jquery 获取父节点
在使用jquery时,很多时候都需要获取当前节点的父节点,包括直接父节点和祖先父节点.用的最多的方法是parent([expr])和parents([expr]).从方法的名字上就可以判断前一个方法是 ...
最新文章
- nodejs 利用zip-local模块压缩文件夹
- vc6怎么看错误在哪_周杰伦超话第一!微博超话在哪进入签到?怎么看排名?不会来看!...
- 图卷积神经网络(part2)--图卷积概述
- 秀秀自己电脑上的好东西
- 四轮驱动移动机器人(SSMR)与两轮差速驱动机器人、car-like robot的对比分析
- TimesTen更改CacheGroup管理用户ORACLE结束和TT结束password【TimesTen操作和维修基地】...
- 业内较好的监控mysql_MySQL监控、性能分析——工具篇
- 小说站源码php采集,关于PHP批量采集----采集小说站有感
- matlab与无网格,无网格法
- Android Adb 连接海马玩模拟器
- 嘉应学院计算机专业毕业好找工作吗,嘉应学院毕业证两字之差致学生求职碰壁...
- 计算机怎么设置本地硬盘启动,怎么设置移动硬盘启动
- 腾讯云web应用防火墙(WAF)防护设置步骤介绍
- java一个方法排他调用_Java编程实现排他锁代码详解
- 计算机发明者约翰·冯·诺依曼
- Workbench导入xls文件
- 利用MATLAB 2016a进行BP神经网络的预测(含有神经网络工具箱)
- Netty系列---源码实例
- jquery如何根据id获取标签内的值,以及如何通过id赋值
- AtCoder Beginner Contest 153 题解
热门文章
- 计算机屏幕怎么睡眠状态,解决办法:显示器进入睡眠状态时如何解决问题
- python 图表 web_Web | Django 与 Chart.js 联用做出精美的图表
- 微软官网html官方文档,微软官方的.net系列文档
- Java黑皮书课后题第10章:*10.1(Time类)设计一个名为Time的类。编写一个测试程序,创建两个Time对象(使用new Time()和new Time(555550000))
- Java黑皮书课后题第6章:*6.21(电话按键盘)国际标准的字母/数字匹配图如编程练习题4.15所示。编写一个测试程序,提示用户输入字符串形式的电话号码。程序将字母(大写或小写)翻译成数字
- 用SqlBulkCopy批量安插数据时提示来自数据源的 String 类型的给定值不能转换为指定目标列的类型 int...
- Jmeter_简单的关联设置
- 从编程角度看32位和64位
- 从 0 到 1 实现 React 系列 —— 4.setState优化和ref的实现
- Qt5.9使用QWebEngineView加载网页速度非常慢,问题解决