Added tasks 846, 847, 848, 849

Author: ThanhNIT

README.md

@@ -109,6 +109,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0847 |[Shortest Path Visiting All Nodes](src/main/kotlin/g0801_0900/s0847_shortest_path_visiting_all_nodes/Solution.kt)| Hard | Dynamic_Programming, Breadth_First_Search, Bit_Manipulation, Graph, Bitmask | 164 | 100.00
 
 #### Day 11 Breadth First Search
 
@@ -1717,6 +1718,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | 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
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
+| 0849 |[Maximize Distance to Closest Person](src/main/kotlin/g0801_0900/s0849_maximize_distance_to_closest_person/Solution.kt)| Medium | Array | 196 | 88.46
+| 0848 |[Shifting Letters](src/main/kotlin/g0801_0900/s0848_shifting_letters/Solution.kt)| Medium | Array, String | 537 | 93.75
+| 0847 |[Shortest Path Visiting All Nodes](src/main/kotlin/g0801_0900/s0847_shortest_path_visiting_all_nodes/Solution.kt)| Hard | Dynamic_Programming, Breadth_First_Search, Bit_Manipulation, Graph, Bitmask, Graph_Theory_I_Day_10_Standard_Traversal | 164 | 100.00
+| 0846 |[Hand of Straights](src/main/kotlin/g0801_0900/s0846_hand_of_straights/Solution.kt)| Medium | Array, Hash_Table, Sorting, Greedy | 306 | 96.15
 | 0845 |[Longest Mountain in Array](src/main/kotlin/g0801_0900/s0845_longest_mountain_in_array/Solution.kt)| Medium | Array, Dynamic_Programming, Two_Pointers, Enumeration | 222 | 100.00
 | 0844 |[Backspace String Compare](src/main/kotlin/g0801_0900/s0844_backspace_string_compare/Solution.kt)| Easy | String, Two_Pointers, Stack, Simulation, Algorithm_II_Day_4_Two_Pointers, Level_1_Day_14_Stack | 126 | 98.31
 | 0843 |[Guess the Word](src/main/kotlin/g0801_0900/s0843_guess_the_word/Solution.kt)| Hard | Array, String, Math, Game_Theory, Interactive | 75 | 100.00

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

@@ -0,0 +1,36 @@
+package g0801_0900.s0846_hand_of_straights
+
+// #Medium #Array #Hash_Table #Sorting #Greedy
+// #2023_03_29_Time_306_ms_(96.15%)_Space_39.4_MB_(46.15%)
+
+class Solution {
+    fun isNStraightHand(hand: IntArray, groupSize: Int): Boolean {
+        val len = hand.size
+        if (len % groupSize != 0) {
+            return false
+        }
+        hand.sort()
+        val map: MutableMap<Int, Int> = HashMap()
+        for (num in hand) {
+            var cnt = map.getOrDefault(num, 0)
+            map[num] = ++cnt
+        }
+        for (num in hand) {
+            var cnt = map[num]!!
+            if (cnt <= 0) {
+                continue
+            }
+            map[num] = --cnt
+            var loop = 1
+            while (loop < groupSize) {
+                var curCnt = map.getOrDefault(num + loop, 0)
+                if (curCnt <= 0) {
+                    return false
+                }
+                map[num + loop] = --curCnt
+                ++loop
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,31 @@
+846\. Hand of Straights
+
+Medium
+
+Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size `groupSize`, and consists of `groupSize` consecutive cards.
+
+Given an integer array `hand` where `hand[i]` is the value written on the <code>i<sup>th</sup></code> card and an integer `groupSize`, return `true` if she can rearrange the cards, or `false` otherwise.
+
+**Example 1:**
+
+**Input:** hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
+
+**Output:** true
+
+**Explanation:** Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]
+
+**Example 2:**
+
+**Input:** hand = [1,2,3,4,5], groupSize = 4
+
+**Output:** false
+
+**Explanation:** Alice's hand can not be rearranged into groups of 4.
+
+**Constraints:**
+
+*   <code>1 <= hand.length <= 10<sup>4</sup></code>
+*   <code>0 <= hand[i] <= 10<sup>9</sup></code>
+*   `1 <= groupSize <= hand.length`
+
+**Note:** This question is the same as 1296: [https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/](https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/)

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

@@ -0,0 +1,46 @@
+package g0801_0900.s0847_shortest_path_visiting_all_nodes
+
+// #Hard #Dynamic_Programming #Breadth_First_Search #Bit_Manipulation #Graph #Bitmask
+// #Graph_Theory_I_Day_10_Standard_Traversal
+// #2023_03_29_Time_164_ms_(100.00%)_Space_35.8_MB_(88.89%)
+
+import java.util.LinkedList
+import java.util.Objects
+import java.util.Queue
+
+class Solution {
+    fun shortestPathLength(graph: Array<IntArray>): Int {
+        val target = (1 shl graph.size) - 1
+        val q: Queue<IntArray> = LinkedList()
+        for (i in graph.indices) {
+            q.offer(intArrayOf(i, 1 shl i))
+        }
+        var steps = 0
+        val visited = Array(graph.size) {
+            BooleanArray(
+                target + 1
+            )
+        }
+        while (!q.isEmpty()) {
+            val size = q.size
+            for (i in 0 until size) {
+                val curr = q.poll()
+                val currNode = Objects.requireNonNull(curr)[0]
+                val currState = curr[1]
+                if (currState == target) {
+                    return steps
+                }
+                for (n in graph[currNode]) {
+                    val newState = currState or (1 shl n)
+                    if (visited[n][newState]) {
+                        continue
+                    }
+                    visited[n][newState] = true
+                    q.offer(intArrayOf(n, newState))
+                }
+            }
+            ++steps
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,36 @@
+847\. Shortest Path Visiting All Nodes
+
+Hard
+
+You have an undirected, connected graph of `n` nodes labeled from `0` to `n - 1`. You are given an array `graph` where `graph[i]` is a list of all the nodes connected with node `i` by an edge.
+
+Return _the length of the shortest path that visits every node_. You may start and stop at any node, you may revisit nodes multiple times, and you may reuse edges.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/12/shortest1-graph.jpg)
+
+**Input:** graph = [[1,2,3],[0],[0],[0]]
+
+**Output:** 4
+
+**Explanation:** One possible path is [1,0,2,0,3]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/05/12/shortest2-graph.jpg)
+
+**Input:** graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]
+
+**Output:** 4
+
+**Explanation:** One possible path is [0,1,4,2,3]
+
+**Constraints:**
+
+*   `n == graph.length`
+*   `1 <= n <= 12`
+*   `0 <= graph[i].length < n`
+*   `graph[i]` does not contain `i`.
+*   If `graph[a]` contains `b`, then `graph[b]` contains `a`.
+*   The input graph is always connected.

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

@@ -0,0 +1,22 @@
+package g0801_0900.s0848_shifting_letters
+
+// #Medium #Array #String #2023_03_29_Time_537_ms_(93.75%)_Space_49.3_MB_(93.75%)
+
+class Solution {
+    fun shiftingLetters(s: String, shifts: IntArray): String {
+        val n = shifts.size
+        var runningSum = 0
+        for (i in n - 1 downTo 0) {
+            shifts[i] = (shifts[i] + runningSum) % 26
+            runningSum = shifts[i]
+        }
+        val str = StringBuilder()
+        var i = 0
+        for (c in s.toCharArray()) {
+            val correctShift = (c.code - 'a'.code + shifts[i]) % 26
+            str.append(('a'.code + correctShift).toChar())
+            i++
+        }
+        return str.toString()
+    }
+}

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

@@ -0,0 +1,40 @@
+848\. Shifting Letters
+
+Medium
+
+You are given a string `s` of lowercase English letters and an integer array `shifts` of the same length.
+
+Call the `shift()` of a letter, the next letter in the alphabet, (wrapping around so that `'z'` becomes `'a'`).
+
+*   For example, `shift('a') = 'b'`, `shift('t') = 'u'`, and `shift('z') = 'a'`.
+
+Now for each `shifts[i] = x`, we want to shift the first `i + 1` letters of `s`, `x` times.
+
+Return _the final string after all such shifts to s are applied_.
+
+**Example 1:**
+
+**Input:** s = "abc", shifts = [3,5,9]
+
+**Output:** "rpl"
+
+**Explanation:** We start with "abc". 
+
+After shifting the first 1 letters of s by 3, we have "dbc".
+
+After shifting the first 2 letters of s by 5, we have "igc". 
+
+After shifting the first 3 letters of s by 9, we have "rpl", the answer.
+
+**Example 2:**
+
+**Input:** s = "aaa", shifts = [1,2,3]
+
+**Output:** "gfd"
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.
+*   `shifts.length == s.length`
+*   <code>0 <= shifts[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,45 @@
+package g0801_0900.s0849_maximize_distance_to_closest_person
+
+// #Medium #Array #2023_03_29_Time_196_ms_(88.46%)_Space_37.6_MB_(76.92%)
+
+class Solution {
+    private var maxDist = 0
+
+    fun maxDistToClosest(seats: IntArray): Int {
+        for (i in seats.indices) {
+            if (seats[i] == 0) {
+                extend(seats, i)
+            }
+        }
+        return maxDist
+    }
+
+    private fun extend(seats: IntArray, position: Int) {
+        var left = position - 1
+        var right = position + 1
+        var leftMinDistance = 1
+        while (left >= 0) {
+            if (seats[left] == 0) {
+                leftMinDistance++
+                left--
+            } else {
+                break
+            }
+        }
+        var rightMinDistance = 1
+        while (right < seats.size) {
+            if (seats[right] == 0) {
+                rightMinDistance++
+                right++
+            } else {
+                break
+            }
+        }
+        val maxReach: Int = when (position) {
+            0 -> rightMinDistance
+            seats.size - 1 -> leftMinDistance
+            else -> leftMinDistance.coerceAtMost(rightMinDistance)
+        }
+        maxDist = maxDist.coerceAtLeast(maxReach)
+    }
+}

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

@@ -0,0 +1,52 @@
+849\. Maximize Distance to Closest Person
+
+Medium
+
+You are given an array representing a row of `seats` where `seats[i] = 1` represents a person sitting in the <code>i<sup>th</sup></code> seat, and `seats[i] = 0` represents that the <code>i<sup>th</sup></code> seat is empty **(0-indexed)**.
+
+There is at least one empty seat, and at least one person sitting.
+
+Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized.
+
+Return _that maximum distance to the closest person_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/10/distance.jpg)
+
+**Input:** seats = [1,0,0,0,1,0,1]
+
+**Output:** 2
+
+**Explanation:**
+
+If Alex sits in the second open seat (i.e. seats[2]), then the closest person has distance 2.
+
+If Alex sits in any other open seat, the closest person has distance 1.
+
+Thus, the maximum distance to the closest person is 2.
+
+**Example 2:**
+
+**Input:** seats = [1,0,0,0]
+
+**Output:** 3
+
+**Explanation:**
+
+If Alex sits in the last seat (i.e. seats[3]), the closest person is 3 seats away.
+
+This is the maximum distance possible, so the answer is 3.
+
+**Example 3:**
+
+**Input:** seats = [0,1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>2 <= seats.length <= 2 * 10<sup>4</sup></code>
+*   `seats[i]` is `0` or `1`.
+*   At least one seat is **empty**.
+*   At least one seat is **occupied**.

src/test/kotlin/g0801_0900/s0846_hand_of_straights/SolutionTest.kt

@@ -0,0 +1,20 @@
+package g0801_0900.s0846_hand_of_straights
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isNStraightHand() {
+        assertThat(
+            Solution().isNStraightHand(intArrayOf(1, 2, 3, 6, 2, 3, 4, 7, 8), 3),
+            equalTo(true)
+        )
+    }
+
+    @Test
+    fun isNStraightHand2() {
+        assertThat(Solution().isNStraightHand(intArrayOf(1, 2, 3, 4, 5), 4), equalTo(false))
+    }
+}

src/test/kotlin/g0801_0900/s0847_shortest_path_visiting_all_nodes/SolutionTest.kt

@@ -0,0 +1,32 @@
+package g0801_0900.s0847_shortest_path_visiting_all_nodes
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun shortestPathLength() {
+        assertThat(
+            Solution().shortestPathLength(arrayOf(intArrayOf(1, 2, 3), intArrayOf(0), intArrayOf(0), intArrayOf(0))),
+            equalTo(4)
+        )
+    }
+
+    @Test
+    fun shortestPathLength2() {
+        assertThat(
+            Solution()
+                .shortestPathLength(
+                    arrayOf(
+                        intArrayOf(1),
+                        intArrayOf(0, 2, 3),
+                        intArrayOf(1, 3, 4),
+                        intArrayOf(2),
+                        intArrayOf(1, 2)
+                    )
+                ),
+            equalTo(4)
+        )
+    }
+}