Added tasks 892, 893, 894, 895

Author: ThanhNIT

README.md

@@ -1725,6 +1725,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
+| 0895 |[Maximum Frequency Stack](src/main/kotlin/g0801_0900/s0895_maximum_frequency_stack/FreqStack.kt)| Hard | Hash_Table, Stack, Design, Ordered_Set | 617 | 100.00
+| 0894 |[All Possible Full Binary Trees](src/main/kotlin/g0801_0900/s0894_all_possible_full_binary_trees/Solution.kt)| Medium | Dynamic_Programming, Tree, Binary_Tree, Recursion, Memoization | 257 | 100.00
+| 0893 |[Groups of Special-Equivalent Strings](src/main/kotlin/g0801_0900/s0893_groups_of_special_equivalent_strings/Solution.kt)| Medium | Array, String, Hash_Table | 141 | 100.00
+| 0892 |[Surface Area of 3D Shapes](src/main/kotlin/g0801_0900/s0892_surface_area_of_3d_shapes/Solution.kt)| Easy | Array, Math, Matrix, Geometry | 180 | 100.00
 | 0891 |[Sum of Subsequence Widths](src/main/kotlin/g0801_0900/s0891_sum_of_subsequence_widths/Solution.kt)| Hard | Array, Math, Sorting | 481 | 100.00
 | 0890 |[Find and Replace Pattern](src/main/kotlin/g0801_0900/s0890_find_and_replace_pattern/Solution.kt)| Medium | Array, String, Hash_Table | 150 | 100.00
 | 0889 |[Construct Binary Tree from Preorder and Postorder Traversal](src/main/kotlin/g0801_0900/s0889_construct_binary_tree_from_preorder_and_postorder_traversal/Solution.kt)| Medium | Array, Hash_Table, Tree, Binary_Tree, Divide_and_Conquer | 168 | 100.00

src/main/kotlin/g0801_0900/s0892_surface_area_of_3d_shapes/Solution.kt

@@ -0,0 +1,36 @@
+package g0801_0900.s0892_surface_area_of_3d_shapes
+
+// #Easy #Array #Math #Matrix #Geometry #2023_04_11_Time_180_ms_(100.00%)_Space_35.8_MB_(100.00%)
+
+class Solution {
+    fun surfaceArea(grid: Array<IntArray>): Int {
+        var surfaceArea = 0
+        for (i in grid.indices) {
+            for (j in grid[i].indices) {
+                if (grid[i][j] > 0) {
+                    surfaceArea += 4 * grid[i][j] + 2
+                    surfaceArea -= hiddenSides(i, j, grid)
+                }
+            }
+        }
+        return surfaceArea
+    }
+
+    private fun hiddenSides(i: Int, j: Int, grid: Array<IntArray>): Int {
+        var hidden = 0
+        val tower = grid[i][j]
+        if (j + 1 < grid[i].size && grid[i][j + 1] > 0) {
+            hidden += tower.coerceAtMost(grid[i][j + 1])
+        }
+        if (j - 1 >= 0 && grid[i][j - 1] > 0) {
+            hidden += tower.coerceAtMost(grid[i][j - 1])
+        }
+        if (i + 1 < grid.size && grid[i + 1][j] > 0) {
+            hidden += tower.coerceAtMost(grid[i + 1][j])
+        }
+        if (i - 1 >= 0 && grid[i - 1][j] > 0) {
+            hidden += tower.coerceAtMost(grid[i - 1][j])
+        }
+        return hidden
+    }
+}

src/main/kotlin/g0801_0900/s0892_surface_area_of_3d_shapes/readme.md

@@ -0,0 +1,41 @@
+892\. Surface Area of 3D Shapes
+
+Easy
+
+You are given an `n x n` `grid` where you have placed some `1 x 1 x 1` cubes. Each value `v = grid[i][j]` represents a tower of `v` cubes placed on top of cell `(i, j)`.
+
+After placing these cubes, you have decided to glue any directly adjacent cubes to each other, forming several irregular 3D shapes.
+
+Return _the total surface area of the resulting shapes_.
+
+**Note:** The bottom face of each shape counts toward its surface area.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/08/tmp-grid2.jpg)
+
+**Input:** grid = [[1,2],[3,4]]
+
+**Output:** 34
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/08/tmp-grid4.jpg)
+
+**Input:** grid = [[1,1,1],[1,0,1],[1,1,1]]
+
+**Output:** 32
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/01/08/tmp-grid5.jpg)
+
+**Input:** grid = [[2,2,2],[2,1,2],[2,2,2]]
+
+**Output:** 46
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   `1 <= n <= 50`
+*   `0 <= grid[i][j] <= 50`

src/main/kotlin/g0801_0900/s0893_groups_of_special_equivalent_strings/Solution.kt

@@ -0,0 +1,31 @@
+package g0801_0900.s0893_groups_of_special_equivalent_strings
+
+// #Medium #Array #String #Hash_Table #2023_04_11_Time_141_ms_(100.00%)_Space_34.7_MB_(100.00%)
+
+class Solution {
+    fun numSpecialEquivGroups(words: Array<String>): Int {
+        val set: HashSet<String> = HashSet()
+        var result = 0
+        for (str in words) {
+            if (set.add(getHashBySwap(str.toCharArray()))) {
+                result++
+            }
+        }
+        return result
+    }
+
+    private fun getHashBySwap(chars: CharArray): String {
+        for (i in chars.indices) {
+            var j = i + 2
+            while (j < chars.size) {
+                if (chars[i] > chars[j]) {
+                    val temp = chars[j]
+                    chars[j] = chars[i]
+                    chars[i] = temp
+                }
+                j += 2
+            }
+        }
+        return String(chars)
+    }
+}

src/main/kotlin/g0801_0900/s0893_groups_of_special_equivalent_strings/readme.md

@@ -0,0 +1,45 @@
+893\. Groups of Special-Equivalent Strings
+
+Medium
+
+You are given an array of strings of the same length `words`.
+
+In one **move**, you can swap any two even indexed characters or any two odd indexed characters of a string `words[i]`.
+
+Two strings `words[i]` and `words[j]` are **special-equivalent** if after any number of moves, `words[i] == words[j]`.
+
+*   For example, `words[i] = "zzxy"` and `words[j] = "xyzz"` are **special-equivalent** because we may make the moves `"zzxy" -> "xzzy" -> "xyzz"`.
+
+A **group of special-equivalent strings** from `words` is a non-empty subset of words such that:
+
+*   Every pair of strings in the group are special equivalent, and
+*   The group is the largest size possible (i.e., there is not a string `words[i]` not in the group such that `words[i]` is special-equivalent to every string in the group).
+
+Return _the number of **groups of special-equivalent strings** from_ `words`.
+
+**Example 1:**
+
+**Input:** words = ["abcd","cdab","cbad","xyzz","zzxy","zzyx"]
+
+**Output:** 3
+
+**Explanation:** 
+
+One group is ["abcd", "cdab", "cbad"], since they are all pairwise special equivalent, and none of the other strings is all pairwise special equivalent to these. 
+
+The other two groups are ["xyzz", "zzxy"] and ["zzyx"].
+
+Note that in particular, "zzxy" is not special equivalent to "zzyx".
+
+**Example 2:**
+
+**Input:** words = ["abc","acb","bac","bca","cab","cba"]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 20`
+*   `words[i]` consist of lowercase English letters.
+*   All the strings are of the same length.

src/main/kotlin/g0801_0900/s0894_all_possible_full_binary_trees/Solution.kt

@@ -0,0 +1,61 @@
+package g0801_0900.s0894_all_possible_full_binary_trees
+
+// #Medium #Dynamic_Programming #Tree #Binary_Tree #Recursion #Memoization
+// #2023_04_11_Time_257_ms_(100.00%)_Space_46.5_MB_(90.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 {
+    fun allPossibleFBT(n: Int): List<TreeNode> {
+        if (n % 2 == 0) {
+            // no complete binary tree possible
+            return ArrayList()
+        }
+        val dp: Array<ArrayList<TreeNode>?> = arrayOfNulls(n + 1)
+        // form left to right
+        var i = 1
+        while (i <= n) {
+            helper(i, dp)
+            i += 2
+        }
+        return dp[n]!!
+    }
+
+    // Using tabulation
+    private fun helper(n: Int, dp: Array<ArrayList<TreeNode>?>) {
+        if (n <= 0) {
+            return
+        }
+        if (n == 1) {
+            dp[1] = ArrayList()
+            dp[1]!!.add(TreeNode(0))
+            return
+        }
+        dp[n] = ArrayList()
+        var i = 1
+        while (i < n) {
+            // left
+            for (nodeL in dp[i]!!) {
+                // right
+                for (nodeR in dp[n - i - 1]!!) {
+                    // 1 node used here
+                    val root = TreeNode(0)
+                    root.left = nodeL
+                    root.right = nodeR
+                    dp[n]!!.add(root)
+                }
+            }
+            i += 2
+        }
+    }
+}

src/main/kotlin/g0801_0900/s0894_all_possible_full_binary_trees/readme.md

@@ -0,0 +1,27 @@
+894\. All Possible Full Binary Trees
+
+Medium
+
+Given an integer `n`, return _a list of all possible **full binary trees** with_ `n` _nodes_. Each node of each tree in the answer must have `Node.val == 0`.
+
+Each element of the answer is the root node of one possible tree. You may return the final list of trees in **any order**.
+
+A **full binary tree** is a binary tree where each node has exactly `0` or `2` children.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/08/22/fivetrees.png)
+
+**Input:** n = 7
+
+**Output:** [[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** [[0,0,0]]
+
+**Constraints:**
+
+*   `1 <= n <= 20`

src/main/kotlin/g0801_0900/s0895_maximum_frequency_stack/FreqStack.kt

@@ -0,0 +1,72 @@
+package g0801_0900.s0895_maximum_frequency_stack
+
+// #Hard #Hash_Table #Stack #Design #Ordered_Set
+// #2023_04_11_Time_617_ms_(100.00%)_Space_62.2_MB_(95.00%)
+
+class FreqStack {
+    private class Node {
+        var next: Node?
+        var `val` = 0
+
+        constructor(`val`: Int) {
+            this.`val` = `val`
+            next = null
+        }
+
+        constructor() {
+            next = null
+        }
+    }
+
+    private class DLL {
+        var head: Node = Node()
+        var size: Int = 0
+
+        fun addNode(x: Int) {
+            val node = Node(x)
+            node.next = head.next
+            head.next = node
+            size++
+        }
+
+        fun removeNode(): Node? {
+            val node = head.next
+            if (node != null) {
+                head.next = node.next
+                node.next = null
+                size--
+            }
+            return node
+        }
+    }
+
+    private var max = 0
+    private val freqMap: HashMap<Int, Int> = HashMap()
+    private val freqListMap: HashMap<Int, DLL> = HashMap()
+
+    fun push(`val`: Int) {
+        val count = freqMap.getOrDefault(`val`, 0) + 1
+        max = max.coerceAtLeast(count)
+        freqMap[`val`] = count
+        val dll = freqListMap.getOrDefault(count, DLL())
+        dll.addNode(`val`)
+        freqListMap[count] = dll
+    }
+
+    fun pop(): Int {
+        val dll = freqListMap[max]
+        val node = dll!!.removeNode()
+        freqMap[node!!.`val`] = max - 1
+        if (dll.size == 0) {
+            max--
+        }
+        return node.`val`
+    }
+}
+
+/*
+ * Your FreqStack object will be instantiated and called as such:
+ * var obj = FreqStack()
+ * obj.push(`val`)
+ * var param_2 = obj.pop()
+ */

src/main/kotlin/g0801_0900/s0895_maximum_frequency_stack/readme.md

@@ -0,0 +1,42 @@
+895\. Maximum Frequency Stack
+
+Hard
+
+Design a stack-like data structure to push elements to the stack and pop the most frequent element from the stack.
+
+Implement the `FreqStack` class:
+
+*   `FreqStack()` constructs an empty frequency stack.
+*   `void push(int val)` pushes an integer `val` onto the top of the stack.
+*   `int pop()` removes and returns the most frequent element in the stack.
+    *   If there is a tie for the most frequent element, the element closest to the stack's top is removed and returned.
+
+**Example 1:**
+
+**Input**
+
+["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"]
+
+[[], [5], [7], [5], [7], [4], [5], [], [], [], []]
+
+**Output:** [null, null, null, null, null, null, null, 5, 7, 5, 4]
+
+**Explanation:**
+
+    FreqStack freqStack = new FreqStack();
+    freqStack.push(5); // The stack is [5]
+    freqStack.push(7); // The stack is [5,7]
+    freqStack.push(5); // The stack is [5,7,5]
+    freqStack.push(7); // The stack is [5,7,5,7]
+    freqStack.push(4); // The stack is [5,7,5,7,4]
+    freqStack.push(5); // The stack is [5,7,5,7,4,5]
+    freqStack.pop(); // return 5, as 5 is the most frequent. The stack becomes [5,7,5,7,4].
+    freqStack.pop(); // return 7, as 5 and 7 is the most frequent, but 7 is closest to the top. The stack becomes [5,7,5,4].
+    freqStack.pop(); // return 5, as 5 is the most frequent. The stack becomes [5,7,4].
+    freqStack.pop(); // return 4, as 4, 5 and 7 is the most frequent, but 4 is closest to the top. The stack becomes [5,7]. 
+
+**Constraints:**
+
+*   <code>0 <= val <= 10<sup>9</sup></code>
+*   At most <code>2 * 10<sup>4</sup></code> calls will be made to `push` and `pop`.
+*   It is guaranteed that there will be at least one element in the stack before calling `pop`.