Added tasks 944, 945, 946, 947

Author: ThanhNIT

README.md

@@ -355,6 +355,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 229 | 79.73
+| 0947 |[Most Stones Removed with Same Row or Column](src/main/kotlin/g0901_1000/s0947_most_stones_removed_with_same_row_or_column/Solution.kt)| Medium | Depth_First_Search, Graph, Union_Find | 200 | 100.00
 
 #### Day 20 Brute Force/Backtracking
 
@@ -1733,6 +1734,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 0947 |[Most Stones Removed with Same Row or Column](src/main/kotlin/g0901_1000/s0947_most_stones_removed_with_same_row_or_column/Solution.kt)| Medium | Depth_First_Search, Graph, Union_Find, Level_2_Day_19_Union_Find | 200 | 100.00
+| 0946 |[Validate Stack Sequences](src/main/kotlin/g0901_1000/s0946_validate_stack_sequences/Solution.kt)| Medium | Array, Stack, Simulation | 180 | 74.91
+| 0945 |[Minimum Increment to Make Array Unique](src/main/kotlin/g0901_1000/s0945_minimum_increment_to_make_array_unique/Solution.kt)| Medium | Array, Sorting, Greedy, Counting | 427 | 100.00
+| 0944 |[Delete Columns to Make Sorted](src/main/kotlin/g0901_1000/s0944_delete_columns_to_make_sorted/Solution.kt)| Easy | Array, String | 221 | 75.00
 | 0943 |[Find the Shortest Superstring](src/main/kotlin/g0901_1000/s0943_find_the_shortest_superstring/Solution.kt)| Hard | Array, String, Dynamic_Programming, Bit_Manipulation, Bitmask | 1290 | 100.00
 | 0942 |[DI String Match](src/main/kotlin/g0901_1000/s0942_di_string_match/Solution.kt)| Easy | Array, String, Math, Greedy, Two_Pointers | 202 | 80.00
 | 0941 |[Valid Mountain Array](src/main/kotlin/g0901_1000/s0941_valid_mountain_array/Solution.kt)| Easy | Array | 251 | 51.94

src/main/kotlin/g0901_1000/s0944_delete_columns_to_make_sorted/Solution.kt

@@ -0,0 +1,20 @@
+package g0901_1000.s0944_delete_columns_to_make_sorted
+
+// #Easy #Array #String #2023_04_30_Time_221_ms_(75.00%)_Space_48.7_MB_(6.25%)
+
+class Solution {
+    fun minDeletionSize(strs: Array<String>): Int {
+        var deleted = 0
+        for (i in 0 until strs[0].length) {
+            var last = ' '
+            for (str in strs) {
+                if (str[i] < last) {
+                    deleted++
+                    break
+                }
+                last = str[i]
+            }
+        }
+        return deleted
+    }
+}

src/main/kotlin/g0901_1000/s0944_delete_columns_to_make_sorted/readme.md

@@ -0,0 +1,68 @@
+944\. Delete Columns to Make Sorted
+
+Easy
+
+You are given an array of `n` strings `strs`, all of the same length.
+
+The strings can be arranged such that there is one on each line, making a grid.
+
+*   For example, `strs = ["abc", "bce", "cae"]` can be arranged as follows:
+
+abc bce cae
+
+You want to **delete** the columns that are **not sorted lexicographically**. In the above example (**0-indexed**), columns 0 (`'a'`, `'b'`, `'c'`) and 2 (`'c'`, `'e'`, `'e'`) are sorted, while column 1 (`'b'`, `'c'`, `'a'`) is not, so you would delete column 1.
+
+Return _the number of columns that you will delete_.
+
+**Example 1:**
+
+**Input:** strs = ["cba","daf","ghi"]
+
+**Output:** 1
+
+**Explanation:** The grid looks as follows: 
+
+cba 
+
+daf 
+
+ghi 
+
+Columns 0 and 2 are sorted, but column 1 is not, so you only need to delete 1 column.
+
+**Example 2:**
+
+**Input:** strs = ["a","b"]
+
+**Output:** 0
+
+**Explanation:** The grid looks as follows: 
+
+a 
+
+b 
+
+Column 0 is the only column and is sorted, so you will not delete any columns.
+
+**Example 3:**
+
+**Input:** strs = ["zyx","wvu","tsr"]
+
+**Output:** 3
+
+**Explanation:** The grid looks as follows: 
+
+zyx 
+
+wvu 
+
+tsr
+
+All 3 columns are not sorted, so you will delete all 3.
+
+**Constraints:**
+
+*   `n == strs.length`
+*   `1 <= n <= 100`
+*   `1 <= strs[i].length <= 1000`
+*   `strs[i]` consists of lowercase English letters.

src/main/kotlin/g0901_1000/s0945_minimum_increment_to_make_array_unique/Solution.kt

@@ -0,0 +1,27 @@
+package g0901_1000.s0945_minimum_increment_to_make_array_unique
+
+// #Medium #Array #Sorting #Greedy #Counting
+// #2023_04_30_Time_427_ms_(100.00%)_Space_101.5_MB_(7.14%)
+
+class Solution {
+    fun minIncrementForUnique(nums: IntArray): Int {
+        var max = 0
+        for (num in nums) {
+            max = Math.max(max, num)
+        }
+        val counts = IntArray(nums.size + max)
+        for (num in nums) {
+            counts[num]++
+        }
+        var minMoves = 0
+        for (i in counts.indices) {
+            if (counts[i] <= 1) {
+                continue
+            }
+            val remaining = counts[i] - 1
+            minMoves += remaining
+            counts[i + 1] = counts[i + 1] + remaining
+        }
+        return minMoves
+    }
+}

src/main/kotlin/g0901_1000/s0945_minimum_increment_to_make_array_unique/readme.md

@@ -0,0 +1,30 @@
+945\. Minimum Increment to Make Array Unique
+
+Medium
+
+You are given an integer array `nums`. In one move, you can pick an index `i` where `0 <= i < nums.length` and increment `nums[i]` by `1`.
+
+Return _the minimum number of moves to make every value in_ `nums` _**unique**_.
+
+The test cases are generated so that the answer fits in a 32-bit integer.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2]
+
+**Output:** 1
+
+**Explanation:** After 1 move, the array could be [1, 2, 3].
+
+**Example 2:**
+
+**Input:** nums = [3,2,1,2,1,7]
+
+**Output:** 6
+
+**Explanation:** After 6 moves, the array could be [3, 4, 1, 2, 5, 7]. It can be shown with 5 or less moves that it is impossible for the array to have all unique values.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g0901_1000/s0946_validate_stack_sequences/Solution.kt

@@ -0,0 +1,34 @@
+package g0901_1000.s0946_validate_stack_sequences
+
+// #Medium #Array #Stack #Simulation #2023_04_30_Time_180_ms_(74.91%)_Space_40.7_MB_(6.18%)
+
+import java.util.Deque
+import java.util.LinkedList
+
+class Solution {
+    fun validateStackSequences(pushed: IntArray, popped: IntArray): Boolean {
+        val stack: Deque<Int> = LinkedList()
+        var i = 0
+        var j = 0
+        val len = pushed.size
+        while (i < len) {
+            if (pushed[i] == popped[j]) {
+                i++
+                j++
+            } else if (!stack.isEmpty() && stack.peek() == popped[j]) {
+                stack.pop()
+                j++
+            } else {
+                stack.push(pushed[i++])
+            }
+        }
+        while (j < len) {
+            if (!stack.isEmpty() && stack.peek() != popped[j++]) {
+                return false
+            } else {
+                stack.pop()
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g0901_1000/s0946_validate_stack_sequences/readme.md

@@ -0,0 +1,43 @@
+946\. Validate Stack Sequences
+
+Medium
+
+Given two integer arrays `pushed` and `popped` each with distinct values, return `true` _if this could have been the result of a sequence of push and pop operations on an initially empty stack, or_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
+
+**Output:** true
+
+**Explanation:** We might do the following sequence:
+
+push(1), push(2), push(3), push(4), 
+
+pop() -> 4, 
+
+push(5), 
+
+pop() -> 5, 
+
+pop() -> 3, 
+
+pop() -> 2, 
+
+pop() -> 1
+
+**Example 2:**
+
+**Input:** pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
+
+**Output:** false
+
+**Explanation:** 1 cannot be popped before 2.
+
+**Constraints:**
+
+*   `1 <= pushed.length <= 1000`
+*   `0 <= pushed[i] <= 1000`
+*   All the elements of `pushed` are **unique**.
+*   `popped.length == pushed.length`
+*   `popped` is a permutation of `pushed`.

src/main/kotlin/g0901_1000/s0947_most_stones_removed_with_same_row_or_column/Solution.kt

@@ -0,0 +1,47 @@
+package g0901_1000.s0947_most_stones_removed_with_same_row_or_column
+
+// #Medium #Depth_First_Search #Graph #Union_Find #Level_2_Day_19_Union_Find
+// #2023_04_30_Time_200_ms_(100.00%)_Space_56_MB_(5.88%)
+
+class Solution {
+    private val roots = IntArray(20002)
+    fun removeStones(stones: Array<IntArray>): Int {
+        for (stone in stones) {
+            init(stone[0] + 1, roots)
+            init(stone[1] + 10000, roots)
+            union(stone[0] + 1, stone[1] + 10000)
+        }
+        val set: HashSet<Int> = HashSet()
+        for (n in roots) {
+            if (n == 0) {
+                continue
+            }
+            set.add(find(n))
+        }
+        return stones.size - set.size
+    }
+
+    private fun init(i: Int, roots: IntArray) {
+        if (roots[i] != 0) {
+            return
+        }
+        roots[i] = i
+    }
+
+    private fun union(i: Int, j: Int) {
+        val ri = find(i)
+        val rj = find(j)
+        if (ri == rj) {
+            return
+        }
+        roots[ri] = rj
+    }
+
+    private fun find(i: Int): Int {
+        var cur = i
+        while (cur != roots[cur]) {
+            cur = roots[roots[cur]]
+        }
+        return cur
+    }
+}

src/main/kotlin/g0901_1000/s0947_most_stones_removed_with_same_row_or_column/readme.md

@@ -0,0 +1,55 @@
+947\. Most Stones Removed with Same Row or Column
+
+Medium
+
+On a 2D plane, we place `n` stones at some integer coordinate points. Each coordinate point may have at most one stone.
+
+A stone can be removed if it shares either **the same row or the same column** as another stone that has not been removed.
+
+Given an array `stones` of length `n` where <code>stones[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents the location of the <code>i<sup>th</sup></code> stone, return _the largest possible number of stones that can be removed_.
+
+**Example 1:**
+
+**Input:** stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
+
+**Output:** 5
+
+**Explanation:** One way to remove 5 stones is as follows:
+
+1. Remove stone [2,2] because it shares the same row as [2,1].
+2. Remove stone [2,1] because it shares the same column as [0,1].
+3. Remove stone [1,2] because it shares the same row as [1,0].
+4. Remove stone [1,0] because it shares the same column as [0,0].
+5. Remove stone [0,1] because it shares the same row as [0,0].
+
+Stone [0,0] cannot be removed since it does not share a row/column with another stone still on the plane.
+
+**Example 2:**
+
+**Input:** stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
+
+**Output:** 3
+
+**Explanation:** One way to make 3 moves is as follows:
+
+1. Remove stone [2,2] because it shares the same row as [2,0].
+
+2. Remove stone [2,0] because it shares the same column as [0,0].
+
+3. Remove stone [0,2] because it shares the same row as [0,0].
+
+Stones [0,0] and [1,1] cannot be removed since they do not share a row/column with another stone still on the plane.
+
+**Example 3:**
+
+**Input:** stones = [[0,0]]
+
+**Output:** 0
+
+**Explanation:** [0,0] is the only stone on the plane, so you cannot remove it.
+
+**Constraints:**
+
+*   `1 <= stones.length <= 1000`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code>
+*   No two stones are at the same coordinate point.

src/test/kotlin/g0901_1000/s0944_delete_columns_to_make_sorted/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0901_1000.s0944_delete_columns_to_make_sorted
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minDeletionSize() {
+        assertThat(Solution().minDeletionSize(arrayOf("cba", "daf", "ghi")), equalTo(1))
+    }
+
+    @Test
+    fun minDeletionSize2() {
+        assertThat(Solution().minDeletionSize(arrayOf("a", "b")), equalTo(0))
+    }
+
+    @Test
+    fun minDeletionSize3() {
+        assertThat(Solution().minDeletionSize(arrayOf("zyx", "wvu", "tsr")), equalTo(3))
+    }
+}

src/test/kotlin/g0901_1000/s0945_minimum_increment_to_make_array_unique/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0901_1000.s0945_minimum_increment_to_make_array_unique
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minIncrementForUnique() {
+        assertThat(Solution().minIncrementForUnique(intArrayOf(1, 2, 2)), equalTo(1))
+    }
+
+    @Test
+    fun minIncrementForUnique2() {
+        assertThat(Solution().minIncrementForUnique(intArrayOf(3, 2, 1, 2, 1, 7)), equalTo(6))
+    }
+}