Added tasks 429, 430, 432, 433.

Author: ThanhNIT

README.md

@@ -318,6 +318,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0429 |[N-ary Tree Level Order Traversal](src/main/kotlin/g0401_0500/s0429_n_ary_tree_level_order_traversal/Solution.kt)| |||
 
 #### Day 10
 
@@ -449,6 +450,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0433 |[Minimum Genetic Mutation](src/main/kotlin/g0401_0500/s0433_minimum_genetic_mutation/Solution.kt)| Medium | String, Hash_Table, Breadth_First_Search | 204 | 82.08
 | 0127 |[Word Ladder](src.save/main/kotlin/g0101_0200/s0127_word_ladder/Solution.kt)| Hard | Top_Interview_Questions, String, Hash_Table, Breadth_First_Search | 396 | 98.68
 
 #### Day 13 Graph Theory
@@ -1628,6 +1630,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
+| 0433 |[Minimum Genetic Mutation](src/main/kotlin/g0401_0500/s0433_minimum_genetic_mutation/Solution.kt)| Medium | String, Hash_Table, Breadth_First_Search, Graph_Theory_I_Day_12_Breadth_First_Search | 204 | 82.08
+| 0432 |[All O\`one Data Structure](src/main/kotlin/g0401_0500/s0432_all_oone_data_structure/AllOne.kt)| Hard | Hash_Table, Design, Linked_List, Doubly_Linked_List | 1200 | 100.00
+| 0430 |[Flatten a Multilevel Doubly Linked List](src/main/kotlin/g0401_0500/s0430_flatten_a_multilevel_doubly_linked_list/Solution.kt)| Medium | Depth_First_Search, Linked_List, Doubly_Linked_List | 194 | 97.44
+| 0429 |[N-ary Tree Level Order Traversal](src/main/kotlin/g0401_0500/s0429_n_ary_tree_level_order_traversal/Solution.kt)| |||
 | 0427 |[Construct Quad Tree](src/main/kotlin/g0401_0500/s0427_construct_quad_tree/Solution.kt)| Medium | Array, Tree, Matrix, Divide_and_Conquer | 221 | 94.74
 | 0424 |[Longest Repeating Character Replacement](src/main/kotlin/g0401_0500/s0424_longest_repeating_character_replacement/Solution.kt)| Medium | String, Hash_Table, Sliding_Window, Level_1_Day_12_Sliding_Window/Two_Pointer | 288 | 84.38
 | 0423 |[Reconstruct Original Digits from English](src/main/kotlin/g0401_0500/s0423_reconstruct_original_digits_from_english/Solution.kt)| Medium | String, Hash_Table, Math | 349 | 100.00

src/main/kotlin/com_github_leetcode/prev_next/Node.kt

@@ -0,0 +1,17 @@
+package com_github_leetcode.prev_next
+
+class Node(var `val`: Int) {
+    constructor(i: Int, node: Node?, node1: Node?, nothing: Node?) : this(i) {
+        this.prev = node
+        this.next = node1
+        this.child = nothing
+    }
+
+    var prev: Node? = null
+    var next: Node? = null
+    var child: Node? = null
+
+    override fun toString(): String {
+        return "Node{val=$`val`,next=${this.next}}"
+    }
+}

src/main/kotlin/g0401_0500/s0429_n_ary_tree_level_order_traversal/Solution.kt

@@ -0,0 +1,23 @@
+package g0401_0500.s0429_n_ary_tree_level_order_traversal
+
+// #Medium #Breadth_First_Search #Tree #Programming_Skills_II_Day_9
+// #2022_12_22_Time_278_ms_(75.00%)_Space_38.9_MB_(87.50%)
+
+import com_github_leetcode.Node
+
+/*
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var neighbors: List<Node?> = listOf()
+ * }
+ */
+
+class Solution {
+    fun levelOrder(root: Node?) = go(listOfNotNull(root), mutableListOf())
+
+    private tailrec fun go(level: List<Node>, acc: MutableList<List<Int>>): List<List<Int>> =
+        if (level.isEmpty()) acc else go(
+            level = level.flatMap(Node::neighbors).filterNotNull(),
+            acc = acc.apply { level.map(Node::`val`).also { add(it) } }
+        )
+}

src/main/kotlin/g0401_0500/s0429_n_ary_tree_level_order_traversal/readme.md

@@ -0,0 +1,28 @@
+429\. N-ary Tree Level Order Traversal
+
+Medium
+
+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)
+
+**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)
+
+**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 <code>[0, 10<sup>4</sup>]</code>

src/main/kotlin/g0401_0500/s0430_flatten_a_multilevel_doubly_linked_list/Solution.kt

@@ -0,0 +1,43 @@
+package g0401_0500.s0430_flatten_a_multilevel_doubly_linked_list
+
+// #Medium #Depth_First_Search #Linked_List #Doubly_Linked_List
+// #2022_12_12_Time_194_ms_(97.44%)_Space_35.5_MB_(87.18%)
+
+import com_github_leetcode.prev_next.Node
+
+/*
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var prev: Node? = null
+ *     var next: Node? = null
+ *     var child: Node? = null
+ * }
+ */
+
+class Solution {
+    fun flatten(root: Node?): Node? {
+        var currentNode = root
+        while (currentNode != null) {
+            if (currentNode?.child != null) {
+                appendToParent(currentNode, currentNode?.next)
+            }
+            currentNode = currentNode?.next
+        }
+        return root
+    }
+
+    fun appendToParent(parent: Node, parentNext: Node?) {
+        var currentNode = parent.child
+        while (currentNode?.next != null) {
+            if (currentNode?.child != null) {
+                appendToParent(currentNode, currentNode?.next)
+            }
+            currentNode = currentNode?.next
+        }
+        parent?.next = parent?.child
+        parent?.child?.prev = parent
+        currentNode?.next = parentNext
+        parentNext?.prev = currentNode
+        parent?.child = null
+    }
+}

src/main/kotlin/g0401_0500/s0430_flatten_a_multilevel_doubly_linked_list/readme.md

@@ -0,0 +1,60 @@
+430\. Flatten a Multilevel Doubly Linked List
+
+Medium
+
+You are given a doubly linked list, which contains nodes that have a next pointer, a previous pointer, and an additional **child pointer**. This child pointer may or may not point to a separate doubly linked list, also containing these special nodes. These child lists may have one or more children of their own, and so on, to produce a **multilevel data structure** as shown in the example below.
+
+Given the `head` of the first level of the list, **flatten** the list so that all the nodes appear in a single-level, doubly linked list. Let `curr` be a node with a child list. The nodes in the child list should appear **after** `curr` and **before** `curr.next` in the flattened list.
+
+Return _the_ `head` _of the flattened list. The nodes in the list must have **all** of their child pointers set to_ `null`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/11/09/flatten11.jpg)
+
+**Input:** head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
+
+**Output:** [1,2,3,7,8,11,12,9,10,4,5,6]
+
+**Explanation:** The multilevel linked list in the input is shown. After flattening the multilevel linked list it becomes: ![](https://assets.leetcode.com/uploads/2021/11/09/flatten12.jpg)
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/11/09/flatten2.1jpg)
+
+**Input:** head = [1,2,null,3]
+
+**Output:** [1,3,2]
+
+**Explanation:** The multilevel linked list in the input is shown. After flattening the multilevel linked list it becomes: ![](https://assets.leetcode.com/uploads/2021/11/24/list.jpg)
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Explanation:** There could be empty list in the input.
+
+**Constraints:**
+
+*   The number of Nodes will not exceed `1000`.
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+
+**How the multilevel linked list is represented in test cases:**
+
+We use the multilevel linked list from **Example 1** above:
+
+1---2---3---4---5---6--NULL | 7---8---9---10--NULL | 11--12--NULL
+
+The serialization of each level is as follows:
+
+[1,2,3,4,5,6,null] [7,8,9,10,null] [11,12,null]
+
+To serialize all levels together, we will add nulls in each level to signify no node connects to the upper node of the previous level. The serialization becomes:
+
+[1, 2, 3, 4, 5, 6, null] | [null, null, 7, 8, 9, 10, null] | [ null, 11, 12, null]
+
+Merging the serialization of each level and removing trailing nulls we obtain:
+
+[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12] 

src/main/kotlin/g0401_0500/s0432_all_oone_data_structure/AllOne.kt

@@ -0,0 +1,125 @@
+package g0401_0500.s0432_all_oone_data_structure
+
+// #Hard #Hash_Table #Design #Linked_List #Doubly_Linked_List
+// #2022_12_21_Time_1200_ms_(100.00%)_Space_123.1_MB_(100.00%)
+
+class AllOne {
+    // maintain a doubly linked list of Buckets
+    private val head: Bucket
+    private val tail: Bucket
+
+    // for accessing a specific Bucket among the Bucket list in O(1) time
+    private val countBucketMap: MutableMap<Int, Bucket?>
+
+    // keep track of count of keys
+    private val keyCountMap: MutableMap<String, Int>
+
+    // each Bucket contains all the keys with the same count
+    private class Bucket(var count: Int) {
+        var keySet: MutableSet<String>
+        var next: Bucket? = null
+        var pre: Bucket? = null
+
+        init {
+            keySet = HashSet()
+        }
+    }
+
+    /* Initialize your data structure here. */
+    init {
+        head = Bucket(Int.MIN_VALUE)
+        tail = Bucket(Int.MAX_VALUE)
+        head.next = tail
+        tail.pre = head
+        countBucketMap = HashMap()
+        keyCountMap = HashMap()
+    }
+
+    /* Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
+    fun inc(key: String) {
+        if (keyCountMap.containsKey(key)) {
+            changeKey(key, 1)
+        } else {
+            keyCountMap[key] = 1
+            if (head.next!!.count != 1) {
+                addBucketAfter(Bucket(1), head)
+            }
+            head.next!!.keySet.add(key)
+            countBucketMap[1] = head.next
+        }
+    }
+
+    /* Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
+    fun dec(key: String) {
+        if (keyCountMap.containsKey(key)) {
+            val count = keyCountMap[key]!!
+            if (count == 1) {
+                keyCountMap.remove(key)
+                removeKeyFromBucket(countBucketMap[count], key)
+            } else {
+                changeKey(key, -1)
+            }
+        }
+    }
+
+    /* Returns one of the keys with maximal value. */
+    fun getMaxKey(): String {
+        return if (tail.pre === head) "" else tail.pre!!.keySet.iterator().next()
+    }
+
+    /* Returns one of the keys with Minimal value. */
+    fun getMinKey(): String {
+        return if (head.next === tail) "" else head.next!!.keySet.iterator().next()
+    }
+
+    // helper function to make change on given key according to offset
+    private fun changeKey(key: String, offset: Int) {
+        val count = keyCountMap[key]!!
+        keyCountMap[key] = count + offset
+        val curBucket = countBucketMap[count]
+        val newBucket: Bucket?
+        if (countBucketMap.containsKey(count + offset)) {
+            // target Bucket already exists
+            newBucket = countBucketMap[count + offset]
+        } else {
+            // add new Bucket
+            newBucket = Bucket(count + offset)
+            countBucketMap[count + offset] = newBucket
+            addBucketAfter(newBucket, if (offset == 1) curBucket else curBucket!!.pre)
+        }
+        newBucket!!.keySet.add(key)
+        removeKeyFromBucket(curBucket, key)
+    }
+
+    private fun removeKeyFromBucket(bucket: Bucket?, key: String) {
+        bucket!!.keySet.remove(key)
+        if (bucket.keySet.isEmpty()) {
+            removeBucketFromList(bucket)
+            countBucketMap.remove(bucket.count)
+        }
+    }
+
+    private fun removeBucketFromList(bucket: Bucket?) {
+        bucket!!.pre!!.next = bucket.next
+        bucket.next!!.pre = bucket.pre
+        bucket.next = null
+        bucket.pre = null
+    }
+
+    // add newBucket after preBucket
+    private fun addBucketAfter(newBucket: Bucket, preBucket: Bucket?) {
+        newBucket.pre = preBucket
+        newBucket.next = preBucket!!.next
+        preBucket.next!!.pre = newBucket
+        preBucket.next = newBucket
+    }
+}
+
+/*
+ * Your AllOne object will be instantiated and called as such:
+ * var obj = AllOne()
+ * obj.inc(key)
+ * obj.dec(key)
+ * var param_3 = obj.getMaxKey()
+ * var param_4 = obj.getMinKey()
+ */

src/main/kotlin/g0401_0500/s0432_all_oone_data_structure/readme.md

@@ -0,0 +1,40 @@
+432\. All O\`one Data Structure
+
+Hard
+
+Design a data structure to store the strings' count with the ability to return the strings with minimum and maximum counts.
+
+Implement the `AllOne` class:
+
+*   `AllOne()` Initializes the object of the data structure.
+*   `inc(String key)` Increments the count of the string `key` by `1`. If `key` does not exist in the data structure, insert it with count `1`.
+*   `dec(String key)` Decrements the count of the string `key` by `1`. If the count of `key` is `0` after the decrement, remove it from the data structure. It is guaranteed that `key` exists in the data structure before the decrement.
+*   `getMaxKey()` Returns one of the keys with the maximal count. If no element exists, return an empty string `""`.
+*   `getMinKey()` Returns one of the keys with the minimum count. If no element exists, return an empty string `""`.
+
+**Example 1:**
+
+**Input**
+
+    ["AllOne", "inc", "inc", "getMaxKey", "getMinKey", "inc", "getMaxKey", "getMinKey"]
+    [[], ["hello"], ["hello"], [], [], ["leet"], [], []]
+
+**Output:** [null, null, null, "hello", "hello", null, "hello", "leet"]
+
+**Explanation:**
+
+    AllOne allOne = new AllOne();
+    allOne.inc("hello");
+    allOne.inc("hello");
+    allOne.getMaxKey(); // return "hello"
+    allOne.getMinKey(); // return "hello"
+    allOne.inc("leet");
+    allOne.getMaxKey(); // return "hello"
+    allOne.getMinKey(); // return "leet" 
+
+**Constraints:**
+
+*   `1 <= key.length <= 10`
+*   `key` consists of lowercase English letters.
+*   It is guaranteed that for each call to `dec`, `key` is existing in the data structure.
+*   At most <code>5 * 10<sup>4</sup></code> calls will be made to `inc`, `dec`, `getMaxKey`, and `getMinKey`.