solves #429: N-ary Tree Level Order Traversal in java

Author: anishLearnsToCode

README.md

@@ -314,6 +314,7 @@
 | 414  | [Third Maximum Number](https://leetcode.com/problems/third-maximum-number)                                                                                             |                                                           [![Java](assets/java.png)](src/ThirdMaximumNumber.java) [![Python](assets/python.png)](python/fizz_buzz.py)                                                            |                                                                                                                                   |
 | 415  | [Add Strings](https://leetcode.com/problems/add-strings)                                                                                                               |                                                               [![Java](assets/java.png)](src/AddString.java) [![Python](assets/python.png)](python/add_strings.py)                                                               |                                                                                                                                   |
 | 422  | 🔒 [Valid Word Square](https://leetcode.com/problems/valid-word-square)                                                                                                |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 429  | 🔒 [N-ary Tree Level Order Traversal](https://leetcode.com/problems/n-ary-tree-level-order-traversal)                                                                  |                                                                                 [![Java](assets/java.png)](src/NAryTreeLevelOrderTraversal.java)                                                                                 |                                                                                                                                   |
 | 430  | [Flatten a Multilevel Doubly Linked List](https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list)                                                       |                                                                             [![Java](assets/java.png)](src/FlattenAMultiLevelDoublyLinkedList.java)                                                                              |                                                                                                                                   |
 | 434  | [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string)                                                                         |                                              [![Java](assets/java.png)](src/NumberOfSegmentsInString.java) [![Python](assets/python.png)](python/number_of_segments_in_a_string.py)                                              |                                                                                                                                   |
 | 441  | [Arranging Coins](https://leetcode.com/problems/arranging-coins)                                                                                                       |                                                          [![Java](assets/java.png)](src/ArrangingCoins.java) [![Python](assets/python.png)](python/arranging_coins.py)                                                           |                                                                                                                                   |

src/NAryTreeLevelOrderTraversal.java

@@ -0,0 +1,56 @@
+// https://leetcode.com/problems/n-ary-tree-level-order-traversal
+// T: O(N)
+// S: O(N)
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class NAryTreeLevelOrderTraversal {
+    public static class Node {
+        public int val;
+        public List<Node> children;
+
+        public Node() {}
+
+        public Node(int _val) {
+            val = _val;
+        }
+
+        public Node(int _val, List<Node> _children) {
+            val = _val;
+            children = _children;
+        }
+    }
+
+    public List<List<Integer>> levelOrder(Node root) {
+        if (root == null) {
+            return new ArrayList<>();
+        }
+
+        final List<List<Integer>> result = new ArrayList<>();
+        final Queue<Node> queue = new LinkedList<>();
+        List<Integer> current = new ArrayList<>();
+
+        queue.add(root);
+        queue.add(null);
+
+        while (!queue.isEmpty()) {
+            final Node node = queue.poll();
+            if (node == null) {
+                result.add(current);
+                current = new ArrayList<>();
+                if (!queue.isEmpty()) {
+                    queue.add(null);
+                }
+                continue;
+            }
+
+            current.add(node.val);
+            queue.addAll(node.children);
+        }
+
+        return result;
+    }
+}

src/PathsInMatrixWhoseSumIsDivisibleByK.java

@@ -0,0 +1,39 @@
+// https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k
+// T: O()
+// S: O()
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class PathsInMatrixWhoseSumIsDivisibleByK {
+    private static final int MODULO = (int) (10e9 + 7);
+
+    public int numberOfPaths(int[][] grid, int k) {
+        final int rows = grid.length, columns = grid[0].length;
+        // row, column, currentSum
+        final Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[] {0, 0, grid[0][0]});
+
+        int paths = 0;
+
+        while (!queue.isEmpty()) {
+            final int[] position = queue.poll();
+            final int row = position[0], column = position[1], currentSum = position[2];
+            if (row == rows - 1 && column == columns - 1) {
+                if (currentSum % k == 0) {
+                    paths = (paths + 1) % MODULO;
+                }
+                continue;
+            }
+
+            if (column + 1 < columns) {
+                queue.add(new int[] { row, column + 1, currentSum + grid[row][column + 1]});
+            }
+            if (row + 1 < rows) {
+                queue.add(new int[] { row + 1, column, currentSum + grid[row + 1][column]});
+            }
+        }
+
+        return paths;
+    }
+}