Commit 4037c67

authored

feat: add solutions to lc problem: No.0863 (#4079)

No.0863.All Nodes Distance K in Binary Tree

1 parent 5bb1fa9 commit 4037c67Copy full SHA for 4037c67

File tree

8 files changed

+307

-479

lines changed

solution/0800-0899/0863.All Nodes Distance K in Binary Tree

8 files changed

+307

-479

lines changed

`‎solution/0800-0899/0863.All Nodes Distance K in Binary Tree/README.md‎`

Lines changed: 102 additions & 165 deletions

Original file line number	Diff line number	Diff line change
`@@ -68,9 +68,11 @@ tags:`
`68`	`68`
`69`	`69`	`### 方法一:DFS + 哈希表`
`70`	`70`
`71`		`-我们先用 DFS 遍历整棵树,记录每个结点的父结点,然后从目标结点开始,向上、向下分别搜索距离为 $k$ 的结点,添加到答案数组中。`
	`71`	`+我们先用 DFS 遍历整棵树,将每个节点的父节点保存到哈希表 $\textit{g}$ 中。`
`72`	`72`
`73`		`-时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 是二叉树的结点数。`
	`73`	`+接下来,我们再次用 DFS,从 $\textit{target}$ 出发,向上向下搜索距离为 $k$ 的节点,添加到结果数组中。`
	`74`	`+`
	`75`	`+时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。`
`74`	`76`
`75`	`77`	`<!-- tabs:start -->`
`76`	`78`
`@@ -87,31 +89,27 @@ tags:`
`87`	`89`
`88`	`90`	`class Solution:`
`89`	`91`	`def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:`
`90`		`- def parents(root, prev):`
`91`		`- nonlocal p`
	`92`	`+ def dfs(root, fa):`
`92`	`93`	`if root is None:`
`93`	`94`	`return`
`94`		`- p[root] = prev`
`95`		`- parents(root.left, root)`
`96`		`- parents(root.right, root)`
	`95`	`+ g[root] = fa`
	`96`	`+ dfs(root.left, root)`
	`97`	`+ dfs(root.right, root)`
`97`	`98`
`98`		`- def dfs(root, k):`
`99`		`- nonlocal ans, vis`
`100`		`- if root is None or root.val in vis:`
	`99`	`+ def dfs2(root, fa, k):`
	`100`	`+ if root is None:`
`101`	`101`	`return`
`102`		`- vis.add(root.val)`
`103`	`102`	`if k == 0:`
`104`	`103`	`ans.append(root.val)`
`105`	`104`	`return`
`106`		`- dfs(root.left, k -1)`
`107`		`- dfs(root.right, k -1)`
`108`		`- dfs(p[root], k - 1)`
	`105`	`+ for nxt in(root.left, root.right, g[root]):`
	`106`	`+ if nxt != fa:`
	`107`	`+ dfs2(nxt, root, k - 1)`
`109`	`108`
`110`		`- p = {}`
`111`		`- parents(root, None)`
	`109`	`+ g = {}`
	`110`	`+ dfs(root, None)`
`112`	`111`	`ans = []`
`113`		`- vis = set()`
`114`		`- dfs(target, k)`
	`112`	`+ dfs2(target, None, k)`
`115`	`113`	`return ans`
`116`	`114`	```
`117`	`115`
`@@ -128,40 +126,37 @@ class Solution:`
`128`	`126`	`* }`
`129`	`127`	`*/`
`130`	`128`	`class Solution {`
`131`		`- private Map<TreeNode, TreeNode> p;`
`132`		`- private Set<Integer> vis;`
`133`		`- private List<Integer> ans;`
	`129`	`+ private Map<TreeNode, TreeNode> g = new HashMap<>();`
	`130`	`+ private List<Integer> ans = new ArrayList<>();`
`134`	`131`
`135`	`132`	`public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {`
`136`		`- p = new HashMap<>();`
`137`		`- vis = new HashSet<>();`
`138`		`- ans = new ArrayList<>();`
`139`		`- parents(root, null);`
`140`		`- dfs(target, k);`
	`133`	`+ dfs(root, null);`
	`134`	`+ dfs2(target, null, k);`
`141`	`135`	`return ans;`
`142`	`136`	`}`
`143`	`137`
`144`		`- private void parents(TreeNode root, TreeNode prev) {`
	`138`	`+ private void dfs(TreeNode root, TreeNode fa) {`
`145`	`139`	`if (root == null) {`
`146`	`140`	`return;`
`147`	`141`	`}`
`148`		`- p.put(root, prev);`
`149`		`- parents(root.left, root);`
`150`		`- parents(root.right, root);`
	`142`	`+ g.put(root, fa);`
	`143`	`+ dfs(root.left, root);`
	`144`	`+ dfs(root.right, root);`
`151`	`145`	`}`
`152`	`146`
`153`		`- private void dfs(TreeNode root, int k) {`
`154`		`- if (root == null\|\| vis.contains(root.val)) {`
	`147`	`+ private void dfs2(TreeNode root, TreeNodefa, int k) {`
	`148`	`+ if (root == null) {`
`155`	`149`	`return;`
`156`	`150`	`}`
`157`		`- vis.add(root.val);`
`158`	`151`	`if (k == 0) {`
`159`	`152`	`ans.add(root.val);`
`160`	`153`	`return;`
`161`	`154`	`}`
`162`		`- dfs(root.left, k - 1);`
`163`		`- dfs(root.right, k - 1);`
`164`		`- dfs(p.get(root), k - 1);`
	`155`	`+ for (TreeNode nxt : new TreeNode[] {root.left, root.right, g.get(root)}) {`
	`156`	`+ if (nxt != fa) {`
	`157`	`+ dfs2(nxt, root, k - 1);`
	`158`	`+ }`
	`159`	`+ }`
`165`	`160`	`}`
`166`	`161`	`}`
`167`	`162`	```
`@@ -180,126 +175,75 @@ class Solution {`
`180`	`175`	`*/`
`181`	`176`	`class Solution {`
`182`	`177`	`public:`
`183`		`- unordered_map<TreeNode, TreeNode> p;`
`184`		`- unordered_set<int> vis;`
`185`		`- vector<int> ans;`
`186`		`-`
`187`	`178`	`vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {`
`188`		`- parents(root, nullptr);`
`189`		`- dfs(target, k);`
	`179`	`+ unordered_map<TreeNode, TreeNode> g;`
	`180`	`+ vector<int> ans;`
	`181`	`+`
	`182`	`+ auto dfs = [&](this auto&& dfs, TreeNode* node, TreeNode* fa) {`
	`183`	`+ if (!node) return;`
	`184`	`+ g[node] = fa;`
	`185`	`+ dfs(node->left, node);`
	`186`	`+ dfs(node->right, node);`
	`187`	`+ };`
	`188`	`+`
	`189`	`+ auto dfs2 = [&](this auto&& dfs2, TreeNode* node, TreeNode* fa, int k) {`
	`190`	`+ if (!node) return;`
	`191`	`+ if (k == 0) {`
	`192`	`+ ans.push_back(node->val);`
	`193`	`+ return;`
	`194`	`+ }`
	`195`	`+ for (auto&& nxt : {node->left, node->right, g[node]}) {`
	`196`	`+ if (nxt != fa) {`
	`197`	`+ dfs2(nxt, node, k - 1);`
	`198`	`+ }`
	`199`	`+ }`
	`200`	`+ };`
	`201`	`+`
	`202`	`+ dfs(root, nullptr);`
	`203`	`+ dfs2(target, nullptr, k);`
`190`	`204`	`return ans;`
`191`	`205`	`}`
`192`		`-`
`193`		`- void parents(TreeNode* root, TreeNode* prev) {`
`194`		`- if (!root) return;`
`195`		`- p[root] = prev;`
`196`		`- parents(root->left, root);`
`197`		`- parents(root->right, root);`
`198`		`- }`
`199`		`-`
`200`		`- void dfs(TreeNode* root, int k) {`
`201`		`- if (!root \|\| vis.count(root->val)) return;`
`202`		`- vis.insert(root->val);`
`203`		`- if (k == 0) {`
`204`		`- ans.push_back(root->val);`
`205`		`- return;`
`206`		`- }`
`207`		`- dfs(root->left, k - 1);`
`208`		`- dfs(root->right, k - 1);`
`209`		`- dfs(p[root], k - 1);`
`210`		`- }`
`211`	`206`	`};`
`212`	`207`	```
`213`	`208`
`214`	`209`	`#### Go`
`215`	`210`
`216`	`211`	```go
`217`		`-/**`
`218`		`- * Definition for a binary tree node.`
`219`		`- * type TreeNode struct {`
`220`		`- * Val int`
`221`		`- * Left *TreeNode`
`222`		`- * Right *TreeNode`
`223`		`- * }`
`224`		`- */`
`225`	`212`	`func distanceK(root TreeNode, target TreeNode, k int) []int {`
`226`		`- p := make(map[TreeNode]TreeNode)`
`227`		`- vis := make(map[int]bool)`
`228`		`- var ans []int`
`229`		`- var parents func(root, prev *TreeNode)`
`230`		`- parents = func(root, prev *TreeNode) {`
`231`		`- if root == nil {`
	`213`	`+ g := make(map[TreeNode]TreeNode)`
	`214`	`+ ans := []int{}`
	`215`	`+`
	`216`	`+ var dfs func(node, fa *TreeNode)`
	`217`	`+ dfs = func(node, fa *TreeNode) {`
	`218`	`+ if node == nil {`
`232`	`219`	`return`
`233`	`220`	`}`
`234`		`- p[root] = prev`
`235`		`- parents(root.Left, root)`
`236`		`- parents(root.Right, root)`
	`221`	`+ g[node] = fa`
	`222`	`+ dfs(node.Left, node)`
	`223`	`+ dfs(node.Right, node)`
`237`	`224`	`}`
`238`		`- parents(root, nil)`
`239`		`- var dfs func(root *TreeNode, k int)`
`240`		`- dfs = func(root *TreeNode, k int) {`
`241`		`- if root == nil \|\| vis[root.Val] {`
	`225`	`+`
	`226`	`+ var dfs2 func(node, fa *TreeNode, k int)`
	`227`	`+ dfs2 = func(node, fa *TreeNode, k int) {`
	`228`	`+ if node == nil {`
`242`	`229`	`return`
`243`	`230`	`}`
`244`		`- vis[root.Val] = true`
`245`	`231`	`if k == 0 {`
`246`		`- ans = append(ans, root.Val)`
	`232`	`+ ans = append(ans, node.Val)`
`247`	`233`	`return`
`248`	`234`	`}`
`249`		`- dfs(root.Left, k-1)`
`250`		`- dfs(root.Right, k-1)`
`251`		`- dfs(p[root], k-1)`
	`235`	`+ for _, nxt := range []*TreeNode{node.Left, node.Right, g[node]} {`
	`236`	`+ if nxt != fa {`
	`237`	`+ dfs2(nxt, node, k-1)`
	`238`	`+ }`
	`239`	`+ }`
`252`	`240`	`}`
`253`		`- dfs(target, k)`
`254`		`- return ans`
`255`		`-}`
`256`		-```
`257`		`-`
`258`		`-<!-- tabs:end -->`
`259`		`-`
`260`		`-<!-- solution:end -->`
`261`		`-`
`262`		`-<!-- solution:start -->`
`263`		`-`
`264`		`-### 方法二`
`265`	`241`
`266`		`-<!-- tabs:start -->`
`267`		`-`
`268`		`-#### Python3`
	`242`	`+ dfs(root, nil)`
	`243`	`+ dfs2(target, nil, k)`
`269`	`244`
`270`		-```python
`271`		`-# Definition for a binary tree node.`
`272`		`-# class TreeNode:`
`273`		`-# def __init__(self, x):`
`274`		`-# self.val = x`
`275`		`-# self.left = None`
`276`		`-# self.right = None`
`277`		`-`
`278`		`-`
`279`		`-class Solution:`
`280`		`- def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:`
`281`		`- def dfs1(root, fa):`
`282`		`- if root is None:`
`283`		`- return`
`284`		`- p[root] = fa`
`285`		`- dfs1(root.left, root)`
`286`		`- dfs1(root.right, root)`
`287`		`-`
`288`		`- def dfs2(root, fa, k):`
`289`		`- if root is None:`
`290`		`- return`
`291`		`- if k == 0:`
`292`		`- ans.append(root.val)`
`293`		`- return`
`294`		`- for nxt in (root.left, root.right, p[root]):`
`295`		`- if nxt != fa:`
`296`		`- dfs2(nxt, root, k - 1)`
`297`		`-`
`298`		`- p = {}`
`299`		`- dfs1(root, None)`
`300`		`- ans = []`
`301`		`- dfs2(target, None, k)`
`302`		`- return ans`
	`245`	`+ return ans`
	`246`	`+}`
`303`	`247`	```
`304`	`248`
`305`	`249`	`#### TypeScript`
`@@ -320,43 +264,36 @@ class Solution:`
`320`	`264`	`*/`
`321`	`265`
`322`	`266`	`function distanceK(root: TreeNode \| null, target: TreeNode \| null, k: number): number[] {`
`323`		`- if (!root) return [0];`
`324`		`-`
`325`		`- const g: Record<number, number[]> = {};`
`326`		`-`
`327`		`- const dfs = (node: TreeNode \| null, parent: TreeNode \| null = null) => {`
`328`		`- if (!node) return;`
`329`		`-`
`330`		`- g[node.val] ??= [];`
`331`		`- if (parent) g[node.val].push(parent.val);`
`332`		`- if (node.left) g[node.val].push(node.left.val);`
`333`		`- if (node.right) g[node.val].push(node.right.val);`
	`267`	`+ const g = new Map<TreeNode, TreeNode \| null>();`
	`268`	`+ const ans: number[] = [];`
`334`	`269`
	`270`	`+ const dfs = (node: TreeNode \| null, fa: TreeNode \| null) => {`
	`271`	`+ if (!node) {`
	`272`	`+ return;`
	`273`	`+ }`
	`274`	`+ g.set(node, fa);`
`335`	`275`	`dfs(node.left, node);`
`336`	`276`	`dfs(node.right, node);`
`337`	`277`	`};`
`338`	`278`
`339`		`- dfs(root);`
`340`		`-`
`341`		`- const vis = new Set<number>();`
`342`		`- let q = [target!.val];`
`343`		`-`
`344`		`- while (q.length) {`
`345`		`- if (!k--) return q;`
`346`		`-`
`347`		`- const nextQ: number[] = [];`
`348`		`-`
`349`		`- for (const x of q) {`
`350`		`- if (vis.has(x)) continue;`
`351`		`-`
`352`		`- vis.add(x);`
`353`		`- nextQ.push(...g[x].filter(x => !vis.has(x)));`
	`279`	`+ const dfs2 = (node: TreeNode \| null, fa: TreeNode \| null, k: number) => {`
	`280`	`+ if (!node) {`
	`281`	`+ return;`
`354`	`282`	`}`
	`283`	`+ if (k === 0) {`
	`284`	`+ ans.push(node.val);`
	`285`	`+ return;`
	`286`	`+ }`
	`287`	`+ for (const nxt of [node.left, node.right, g.get(node) \|\| null]) {`
	`288`	`+ if (nxt !== fa) {`
	`289`	`+ dfs2(nxt, node, k - 1);`
	`290`	`+ }`
	`291`	`+ }`
	`292`	`+ };`
`355`	`293`
`356`		`- q = nextQ;`
`357`		`- }`
`358`		`-`
`359`		`- return [];`
	`294`	`+ dfs(root, null);`
	`295`	`+ dfs2(target, null, k);`
	`296`	`+ return ans;`
`360`	`297`	`}`
`361`	`298`	```
`362`	`299`

0 commit comments

Comments

(0)

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

Commit 4037c67

File tree

8 files changed

8 files changed

`‎solution/0800-0899/0863.All Nodes Distance K in Binary Tree/README.md‎`

0 commit comments