Added tasks 558, 559, 561, 563

Author: ThanhNIT

README.md

@@ -1655,7 +1655,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0563 |[Binary Tree Tilt](src/main/kotlin/g0501_0600/s0563_binary_tree_tilt/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 197 | 100.00
+| 0561 |[Array Partition](src/main/kotlin/g0501_0600/s0561_array_partition_i/Solution.kt)| Easy | Array, Sorting, Greedy, Counting_Sort | 337 | 90.48
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
+| 0559 |[Maximum Depth of N-ary Tree](src/main/kotlin/g0501_0600/s0559_maximum_depth_of_n_ary_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree | 196 | 100.00
+| 0558 |[Logical OR of Two Binary Grids Represented as Quad-Trees](src/main/kotlin/g0501_0600/s0558_logical_or_of_two_binary_grids_represented_as_quad_trees/Solution.kt)| Medium | Tree, Divide_and_Conquer | 268 | 100.00
 | 0557 |[Reverse Words in a String III](src/main/kotlin/g0501_0600/s0557_reverse_words_in_a_string_iii/Solution.kt)| Easy | String, Two_Pointers, Algorithm_I_Day_4_Two_Pointers | 215 | 98.10
 | 0556 |[Next Greater Element III](src/main/kotlin/g0501_0600/s0556_next_greater_element_iii/Solution.kt)| Medium | String, Math, Two_Pointers, Programming_Skills_II_Day_10 | 137 | 80.00
 | 0554 |[Brick Wall](src/main/kotlin/g0501_0600/s0554_brick_wall/Solution.kt)| Medium | Array, Hash_Table | 307 | 100.00

src/main/kotlin/g0501_0600/s0558_logical_or_of_two_binary_grids_represented_as_quad_trees/Node.kt

@@ -0,0 +1,49 @@
+package g0501_0600.s0558_logical_or_of_two_binary_grids_represented_as_quad_trees
+
+/*
+ * Definition for a QuadTree node.
+ * class Node(var `val`: Boolean, var isLeaf: Boolean) {
+ *     var topLeft: Node? = null
+ *     var topRight: Node? = null
+ *     var bottomLeft: Node? = null
+ *     var bottomRight: Node? = null
+ * }
+ */
+
+class Node {
+    var `val` = false
+    var isLeaf = false
+    var topLeft: Node? = null
+    var topRight: Node? = null
+    var bottomLeft: Node? = null
+    var bottomRight: Node? = null
+
+    constructor() {
+        // empty constructor
+    }
+
+    constructor(`val`: Boolean, isLeaf: Boolean) {
+        this.`val` = `val`
+        this.isLeaf = isLeaf
+        topLeft = null
+        topRight = null
+        bottomLeft = null
+        bottomRight = null
+    }
+
+    override fun toString(): String {
+        return (
+            getNode(this) +
+                getNode(topLeft) +
+                getNode(topRight) +
+                getNode(bottomLeft) +
+                getNode(bottomRight)
+            )
+    }
+
+    private fun getNode(node: Node?): String {
+        val isLeafLocal = if (node!!.isLeaf) "1" else "0"
+        val valLocal = if (node.`val`) "1" else "0"
+        return "[$isLeafLocal,$valLocal]"
+    }
+}

src/main/kotlin/g0501_0600/s0558_logical_or_of_two_binary_grids_represented_as_quad_trees/Solution.kt

@@ -0,0 +1,45 @@
+package g0501_0600.s0558_logical_or_of_two_binary_grids_represented_as_quad_trees
+
+// #Medium #Tree #Divide_and_Conquer #2023_01_20_Time_268_ms_(100.00%)_Space_44.2_MB_(100.00%)
+
+/*
+ * Definition for a QuadTree node.
+ * class Node(var `val`: Boolean, var isLeaf: Boolean) {
+ *     var topLeft: Node? = null
+ *     var topRight: Node? = null
+ *     var bottomLeft: Node? = null
+ *     var bottomRight: Node? = null
+ * }
+ */
+
+class Solution {
+    fun intersect(quadTree1: Node?, quadTree2: Node?): Node? {
+        if (quadTree1!!.isLeaf) {
+            return if (quadTree1.`val`) quadTree1 else quadTree2
+        }
+        if (quadTree2!!.isLeaf) {
+            return if (quadTree2.`val`) quadTree2 else quadTree1
+        }
+        val out = Node()
+        val tl: Node? = intersect(quadTree1.topLeft, quadTree2.topLeft)
+        val tr: Node? = intersect(quadTree1.topRight, quadTree2.topRight)
+        val bl: Node? = intersect(quadTree1.bottomLeft, quadTree2.bottomLeft)
+        val br: Node? = intersect(quadTree1.bottomRight, quadTree2.bottomRight)
+        if ((
+            tl!!.isLeaf &&
+                tr!!.isLeaf &&
+                bl!!.isLeaf &&
+                br!!.isLeaf && tl.`val` == tr.`val`
+            ) && tr.`val` == bl.`val` && br.`val` == bl.`val`
+        ) {
+            out.isLeaf = true
+            out.`val` = tl.`val`
+        } else {
+            out.topLeft = tl
+            out.topRight = tr
+            out.bottomLeft = bl
+            out.bottomRight = br
+        }
+        return out
+    }
+}

src/main/kotlin/g0501_0600/s0558_logical_or_of_two_binary_grids_represented_as_quad_trees/readme.md

@@ -0,0 +1,66 @@
+558\. Logical OR of Two Binary Grids Represented as Quad-Trees
+
+Medium
+
+A Binary Matrix is a matrix in which all the elements are either **0** or **1**.
+
+Given `quadTree1` and `quadTree2`. `quadTree1` represents a `n * n` binary matrix and `quadTree2` represents another `n * n` binary matrix.
+
+Return _a Quad-Tree_ representing the `n * n` binary matrix which is the result of **logical bitwise OR** of the two binary matrixes represented by `quadTree1` and `quadTree2`.
+
+Notice that you can assign the value of a node to **True** or **False** when `isLeaf` is **False**, and both are **accepted** in the answer.
+
+A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:
+
+*   `val`: True if the node represents a grid of 1's or False if the node represents a grid of 0's.
+*   `isLeaf`: True if the node is leaf node on the tree or False if the node has the four children.
+
+    class Node {
+    public boolean val;
+    public boolean isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+    }
+
+We can construct a Quad-Tree from a two-dimensional area using the following steps:
+
+1.  If the current grid has the same value (i.e all `1's` or all `0's`) set `isLeaf` True and set `val` to the value of the grid and set the four children to Null and stop.
+2.  If the current grid has different values, set `isLeaf` to False and set `val` to any value and divide the current grid into four sub-grids as shown in the photo.
+3.  Recurse for each of the children with the proper sub-grid.
+
+![](https://assets.leetcode.com/uploads/2020/02/11/new_top.png)
+
+If you want to know more about the Quad-Tree, you can refer to the [wiki](https://en.wikipedia.org/wiki/Quadtree).
+
+**Quad-Tree format:**
+
+The input/output represents the serialized format of a Quad-Tree using level order traversal, where `null` signifies a path terminator where no node exists below.
+
+It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list `[isLeaf, val]`.
+
+If the value of `isLeaf` or `val` is True we represent it as **1** in the list `[isLeaf, val]` and if the value of `isLeaf` or `val` is False we represent it as **0**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/02/11/qt1.png) ![](https://assets.leetcode.com/uploads/2020/02/11/qt2.png)
+
+**Input:** quadTree1 = [[0,1],[1,1],[1,1],[1,0],[1,0]] , quadTree2 = [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
+
+**Output:** [[0,0],[1,1],[1,1],[1,1],[1,0]]
+
+**Explanation:** quadTree1 and quadTree2 are shown above. You can see the binary matrix which is represented by each Quad-Tree. If we apply logical bitwise OR on the two binary matrices we get the binary matrix below which is represented by the result Quad-Tree. Notice that the binary matrices shown are only for illustration, you don't have to construct the binary matrix to get the result tree. ![](https://assets.leetcode.com/uploads/2020/02/11/qtr.png)
+
+**Example 2:**
+
+**Input:** quadTree1 = [[1,0]], quadTree2 = [[1,0]]
+
+**Output:** [[1,0]]
+
+**Explanation:** Each tree represents a binary matrix of size 1\*1. Each matrix contains only zero. The resulting matrix is of size 1\*1 with also zero.
+
+**Constraints:**
+
+*   `quadTree1` and `quadTree2` are both **valid** Quad-Trees each representing a `n * n` grid.
+*   <code>n == 2<sup>x</sup></code> where `0 <= x <= 9`.

src/main/kotlin/g0501_0600/s0559_maximum_depth_of_n_ary_tree/Solution.kt

@@ -0,0 +1,40 @@
+package g0501_0600.s0559_maximum_depth_of_n_ary_tree
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree
+// #2023_01_21_Time_196_ms_(100.00%)_Space_37.6_MB_(92.31%)
+
+import com_github_leetcode.Node
+
+/*
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var neighbors: List<Node?> = listOf()
+ * }
+ */
+
+class Solution {
+    private var max = 0
+
+    fun maxDepth(root: Node?): Int {
+        if (root == null) {
+            return 0
+        }
+        if (root.neighbors.isEmpty()) {
+            return 1
+        }
+        for (child in root.neighbors) {
+            findDepth(child, 1)
+        }
+        return max
+    }
+
+    private fun findDepth(n: Node?, d: Int) {
+        if (!n!!.neighbors.isEmpty()) {
+            for (no in n.neighbors) {
+                findDepth(no, d + 1)
+            }
+        } else {
+            max = Math.max(max, d + 1)
+        }
+    }
+}

src/main/kotlin/g0501_0600/s0559_maximum_depth_of_n_ary_tree/readme.md

@@ -0,0 +1,30 @@
+559\. Maximum Depth of N-ary Tree
+
+Easy
+
+Given a n-ary tree, find its maximum depth.
+
+The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+_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:** 3
+
+**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:** 5
+
+**Constraints:**
+
+*   The total number of nodes is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   The depth of the n-ary tree is less than or equal to `1000`.

src/main/kotlin/g0501_0600/s0561_array_partition_i/Solution.kt

@@ -0,0 +1,17 @@
+package g0501_0600.s0561_array_partition_i
+
+// #Easy #Array #Sorting #Greedy #Counting_Sort
+// #2023_01_21_Time_337_ms_(90.48%)_Space_41.1_MB_(97.62%)
+
+class Solution {
+    fun arrayPairSum(nums: IntArray): Int {
+        nums.sort()
+        var sum = 0
+        var i = 0
+        while (i < nums.size - 1) {
+            sum += Math.min(nums[i], nums[i + 1])
+            i = i + 2
+        }
+        return sum
+    }
+}

src/main/kotlin/g0501_0600/s0561_array_partition_i/readme.md

@@ -0,0 +1,30 @@
+561\. Array Partition
+
+Easy
+
+Given an integer array `nums` of `2n` integers, group these integers into `n` pairs <code>(a<sub>1</sub>, b<sub>1</sub>), (a<sub>2</sub>, b<sub>2</sub>), ..., (a<sub>n</sub>, b<sub>n</sub>)</code> such that the sum of <code>min(a<sub>i</sub>, b<sub>i</sub>)</code> for all `i` is **maximized**. Return _the maximized sum_.
+
+**Example 1:**
+
+**Input:** nums = [1,4,3,2]
+
+**Output:** 4
+
+**Explanation:** All possible pairings (ignoring the ordering of elements) are:
+1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3 
+2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3 
+3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4 So the maximum possible sum is 4.
+
+**Example 2:**
+
+**Input:** nums = [6,2,6,5,1,2]
+
+**Output:** 9
+
+**Explanation:** The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   `nums.length == 2 * n`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>

src/main/kotlin/g0501_0600/s0563_binary_tree_tilt/Solution.kt

@@ -0,0 +1,35 @@
+package g0501_0600.s0563_binary_tree_tilt
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree
+// #2023_01_21_Time_197_ms_(100.00%)_Space_35.8_MB_(75.00%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var sum = 0
+    private fun sumTilt(root: TreeNode?): Int {
+        if (root == null) {
+            return 0
+        }
+        val ls = sumTilt(root.left)
+        val rs = sumTilt(root.right)
+        sum += Math.abs(ls - rs)
+        return ls + rs + root.`val`
+    }
+
+    fun findTilt(root: TreeNode?): Int {
+        sum = 0
+        sumTilt(root)
+        return sum
+    }
+}

src/main/kotlin/g0501_0600/s0563_binary_tree_tilt/readme.md

@@ -0,0 +1,53 @@
+563\. Binary Tree Tilt
+
+Easy
+
+Given the `root` of a binary tree, return _the sum of every tree node's **tilt**._
+
+The **tilt** of a tree node is the **absolute difference** between the sum of all left subtree node **values** and all right subtree node **values**. If a node does not have a left child, then the sum of the left subtree node **values** is treated as `0`. The rule is similar if the node does not have a right child.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/20/tilt1.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 1
+
+**Explanation:**
+
+    Tilt of node 2 : |0-0| = 0 (no children)
+    Tilt of node 3 : |0-0| = 0 (no children)
+    Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3) 
+    Sum of every tilt : 0 + 0 + 1 = 1
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/20/tilt2.jpg)
+
+**Input:** root = [4,2,9,3,5,null,7]
+
+**Output:** 15
+
+**Explanation:**
+
+    Tilt of node 3 : |0-0| = 0 (no children) 
+    Tilt of node 5 : |0-0| = 0 (no children) 
+    Tilt of node 7 : |0-0| = 0 (no children) 
+    Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5) 
+    Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7) 
+    Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16) 
+    Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2020/10/20/tilt3.jpg)
+
+**Input:** root = [21,7,14,1,1,2,2,3,3]
+
+**Output:** 9
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   `-1000 <= Node.val <= 1000`