Add solution 0429

Author: halfrost

README.md

@@ -0,0 +1,39 @@
+package leetcode
+
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func levelOrder(root *Node) [][]int {
+	var res [][]int
+	var temp []int
+	if root == nil {
+		return res
+	}
+	queue := []*Node{root, nil}
+	for len(queue) > 1 {
+		node := queue[0]
+		queue = queue[1:]
+		if node == nil {
+			queue = append(queue, nil)
+			res = append(res, temp)
+			temp = []int{}
+		} else {
+			temp = append(temp, node.Val)
+			if len(node.Children) > 0 {
+				queue = append(queue, node.Children...)
+			}
+		}
+	}
+	res = append(res, temp)
+	return res
+}

leetcode/0429.N-ary-Tree-Level-Order-Traversal/429. N-ary Tree Level Order Traversal.go

@@ -0,0 +1,85 @@
+# [429. N-ary Tree Level Order Traversal](https://leetcode.com/problems/n-ary-tree-level-order-traversal/)
+
+
+## 题目
+
+Given an n-ary tree, return the *level order* traversal of its nodes' values.
+
+*Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).*
+
+**Example 1:**
+
+![https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png](https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png)
+
+```
+Input: root = [1,null,3,2,4,null,5,6]
+Output: [[1],[3,2,4],[5,6]]
+
+```
+
+**Example 2:**
+
+![https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png](https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png)
+
+```
+Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+Output: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
+
+```
+
+**Constraints:**
+
+- The height of the n-ary tree is less than or equal to `1000`
+- The total number of nodes is between `[0, 104]`
+
+## 题目大意
+
+给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
+
+## 解题思路
+
+- 这是 n 叉树的系列题，第 589 题也是这一系列的题目。这一题思路不难，既然是层序遍历，用 BFS 解答。
+
+## 代码
+
+```go
+package leetcode
+
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func levelOrder(root *Node) [][]int {
+	var res [][]int
+	var temp []int
+	if root == nil {
+		return res
+	}
+	queue := []*Node{root, nil}
+	for len(queue) > 1 {
+		node := queue[0]
+		queue = queue[1:]
+		if node == nil {
+			queue = append(queue, nil)
+			res = append(res, temp)
+			temp = []int{}
+		} else {
+			temp = append(temp, node.Val)
+			if len(node.Children) > 0 {
+				queue = append(queue, node.Children...)
+			}
+		}
+	}
+	res = append(res, temp)
+	return res
+}
+```

leetcode/0429.N-ary-Tree-Level-Order-Traversal/429. N-ary Tree Level Order Traversal_test.go

@@ -88,5 +88,5 @@ func max(a int, b int) int {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0423.Reconstruct-Original-Digits-from-English/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0433.Minimum-Genetic-Mutation/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0429.N-ary-Tree-Level-Order-Traversal/">下一页➡️</a></p>
 </div>

leetcode/0429.N-ary-Tree-Level-Order-Traversal/README.md

@@ -0,0 +1,92 @@
+# [429.N-ary Tree Level Order Traversal](https://leetcode.com/problems/n-ary-tree-level-order-traversal/)
+
+
+## 题目
+
+Given an n-ary tree, return the *level order* traversal of its nodes' values.
+
+*Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).*
+
+**Example 1:**
+
+![https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png](https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png)
+
+```
+Input: root = [1,null,3,2,4,null,5,6]
+Output: [[1],[3,2,4],[5,6]]
+
+```
+
+**Example 2:**
+
+![https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png](https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png)
+
+```
+Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+Output: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
+
+```
+
+**Constraints:**
+
+- The height of the n-ary tree is less than or equal to `1000`
+- The total number of nodes is between `[0, 104]`
+
+## 题目大意
+
+给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
+
+## 解题思路
+
+- 这是 n 叉树的系列题，第 589 题也是这一系列的题目。这一题思路不难，既然是层序遍历，用 BFS 解答。
+
+## 代码
+
+```go
+package leetcode
+
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func levelOrder(root *Node) [][]int {
+	var res [][]int
+	var temp []int
+	if root == nil {
+		return res
+	}
+	queue := []*Node{root, nil}
+	for len(queue) > 1 {
+		node := queue[0]
+		queue = queue[1:]
+		if node == nil {
+			queue = append(queue, nil)
+			res = append(res, temp)
+			temp = []int{}
+		} else {
+			temp = append(temp, node.Val)
+			if len(node.Children) > 0 {
+				queue = append(queue, node.Children...)
+			}
+		}
+	}
+	res = append(res, temp)
+	return res
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0424.Longest-Repeating-Character-Replacement/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0433.Minimum-Genetic-Mutation/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/0400~0499/0424.Longest-Repeating-Character-Replacement.md

@@ -185,6 +185,6 @@ func convert(gene string) uint32 {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0424.Longest-Repeating-Character-Replacement/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0429.N-ary-Tree-Level-Order-Traversal/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0435.Non-overlapping-Intervals/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/0400~0499/0429.N-ary-Tree-Level-Order-Traversal.md

@@ -191,7 +191,7 @@ weight: 1
 |0713|Subarray Product Less Than K|[Go]({{< relref "/ChapterFour/0700~0799/0713.Subarray-Product-Less-Than-K.md" >}})|Medium| O(n)| O(1)||41.2%|
 |0714|Best Time to Buy and Sell Stock with Transaction Fee|[Go]({{< relref "/ChapterFour/0700~0799/0714.Best-Time-to-Buy-and-Sell-Stock-with-Transaction-Fee.md" >}})|Medium| O(n)| O(1)||59.0%|
 |0717|1-bit and 2-bit Characters|[Go]({{< relref "/ChapterFour/0700~0799/0717.1-bit-and-2-bit-Characters.md" >}})|Easy||||46.3%|
-|0718|Maximum Length of Repeated Subarray|[Go]({{< relref "/ChapterFour/0700~0799/0718.Maximum-Length-of-Repeated-Subarray.md" >}})|Medium||||51.0%|
+|0718|Maximum Length of Repeated Subarray|[Go]({{< relref "/ChapterFour/0700~0799/0718.Maximum-Length-of-Repeated-Subarray.md" >}})|Medium||||51.1%|
 |0719|Find K-th Smallest Pair Distance|[Go]({{< relref "/ChapterFour/0700~0799/0719.Find-K-th-Smallest-Pair-Distance.md" >}})|Hard||||33.2%|
 |0720|Longest Word in Dictionary|[Go]({{< relref "/ChapterFour/0700~0799/0720.Longest-Word-in-Dictionary.md" >}})|Medium||||49.9%|
 |0721|Accounts Merge|[Go]({{< relref "/ChapterFour/0700~0799/0721.Accounts-Merge.md" >}})|Medium||||53.4%|
@@ -250,7 +250,7 @@ weight: 1
 |0927|Three Equal Parts|[Go]({{< relref "/ChapterFour/0900~0999/0927.Three-Equal-Parts.md" >}})|Hard||||39.1%|
 |0928|Minimize Malware Spread II|[Go]({{< relref "/ChapterFour/0900~0999/0928.Minimize-Malware-Spread-II.md" >}})|Hard||||41.6%|
 |0930|Binary Subarrays With Sum|[Go]({{< relref "/ChapterFour/0900~0999/0930.Binary-Subarrays-With-Sum.md" >}})|Medium||||46.3%|
-|0942|DI String Match|[Go]({{< relref "/ChapterFour/0900~0999/0942.DI-String-Match.md" >}})|Easy||||74.5%|
+|0942|DI String Match|[Go]({{< relref "/ChapterFour/0900~0999/0942.DI-String-Match.md" >}})|Easy||||74.6%|
 |0946|Validate Stack Sequences|[Go]({{< relref "/ChapterFour/0900~0999/0946.Validate-Stack-Sequences.md" >}})|Medium||||64.6%|
 |0952|Largest Component Size by Common Factor|[Go]({{< relref "/ChapterFour/0900~0999/0952.Largest-Component-Size-by-Common-Factor.md" >}})|Hard||||36.6%|
 |0953|Verifying an Alien Dictionary|[Go]({{< relref "/ChapterFour/0900~0999/0953.Verifying-an-Alien-Dictionary.md" >}})|Easy||||52.1%|

website/content/ChapterFour/0400~0499/0433.Minimum-Genetic-Mutation.md

@@ -130,7 +130,7 @@ func updateMatrix_BFS(matrix [][]int) [][]int {
 |0526|Beautiful Arrangement|[Go]({{< relref "/ChapterFour/0500~0599/0526.Beautiful-Arrangement.md" >}})|Medium| O(n^2)| O(1)|❤️|62.5%|
 |0638|Shopping Offers|[Go]({{< relref "/ChapterFour/0600~0699/0638.Shopping-Offers.md" >}})|Medium||||53.9%|
 |0784|Letter Case Permutation|[Go]({{< relref "/ChapterFour/0700~0799/0784.Letter-Case-Permutation.md" >}})|Medium| O(n)| O(n)||69.5%|
-|0816|Ambiguous Coordinates|[Go]({{< relref "/ChapterFour/0800~0899/0816.Ambiguous-Coordinates.md" >}})|Medium||||55.7%|
+|0816|Ambiguous Coordinates|[Go]({{< relref "/ChapterFour/0800~0899/0816.Ambiguous-Coordinates.md" >}})|Medium||||55.6%|
 |0842|Split Array into Fibonacci Sequence|[Go]({{< relref "/ChapterFour/0800~0899/0842.Split-Array-into-Fibonacci-Sequence.md" >}})|Medium| O(n^2)| O(1)|❤️|37.2%|
 |0980|Unique Paths III|[Go]({{< relref "/ChapterFour/0900~0999/0980.Unique-Paths-III.md" >}})|Hard| O(n log n)| O(n)||77.3%|
 |0996|Number of Squareful Arrays|[Go]({{< relref "/ChapterFour/0900~0999/0996.Number-of-Squareful-Arrays.md" >}})|Hard| O(n log n)| O(n) ||48.7%|

website/content/ChapterTwo/Array.md

@@ -173,7 +173,7 @@ func peakIndexInMountainArray(A []int) int {
 |0668|Kth Smallest Number in Multiplication Table|[Go]({{< relref "/ChapterFour/0600~0699/0668.Kth-Smallest-Number-in-Multiplication-Table.md" >}})|Hard||||48.5%|
 |0704|Binary Search|[Go]({{< relref "/ChapterFour/0700~0799/0704.Binary-Search.md" >}})|Easy||||54.9%|
 |0710|Random Pick with Blacklist|[Go]({{< relref "/ChapterFour/0700~0799/0710.Random-Pick-with-Blacklist.md" >}})|Hard| O(n)| O(n)  ||33.3%|
-|0718|Maximum Length of Repeated Subarray|[Go]({{< relref "/ChapterFour/0700~0799/0718.Maximum-Length-of-Repeated-Subarray.md" >}})|Medium||||51.0%|
+|0718|Maximum Length of Repeated Subarray|[Go]({{< relref "/ChapterFour/0700~0799/0718.Maximum-Length-of-Repeated-Subarray.md" >}})|Medium||||51.1%|
 |0719|Find K-th Smallest Pair Distance|[Go]({{< relref "/ChapterFour/0700~0799/0719.Find-K-th-Smallest-Pair-Distance.md" >}})|Hard||||33.2%|
 |0744|Find Smallest Letter Greater Than Target|[Go]({{< relref "/ChapterFour/0700~0799/0744.Find-Smallest-Letter-Greater-Than-Target.md" >}})|Easy||||45.8%|
 |0778|Swim in Rising Water|[Go]({{< relref "/ChapterFour/0700~0799/0778.Swim-in-Rising-Water.md" >}})|Hard||||57.8%|