Added tasks 3550-3553

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3553 |[Minimum Weighted Subgraph With the Required Paths II](src/main/kotlin/g3501_3600/s3553_minimum_weighted_subgraph_with_the_required_paths_ii)| Hard | Array, Depth_First_Search, Tree | 142 | 100.00
+| 3552 |[Grid Teleportation Traversal](src/main/kotlin/g3501_3600/s3552_grid_teleportation_traversal)| Medium | Array, Hash_Table, Breadth_First_Search, Matrix | 147 | 100.00
+| 3551 |[Minimum Swaps to Sort by Digit Sum](src/main/kotlin/g3501_3600/s3551_minimum_swaps_to_sort_by_digit_sum)| Medium | Array, Hash_Table, Sorting | 481 | 83.33
+| 3550 |[Smallest Index With Digit Sum Equal to Index](src/main/kotlin/g3501_3600/s3550_smallest_index_with_digit_sum_equal_to_index)| Easy | Array, Math | 1 | 100.00
 | 3548 |[Equal Sum Grid Partition II](src/main/kotlin/g3501_3600/s3548_equal_sum_grid_partition_ii)| Hard | Array, Hash_Table, Matrix, Prefix_Sum, Enumeration | 61 | 100.00
 | 3547 |[Maximum Sum of Edge Values in a Graph](src/main/kotlin/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph)| Hard | Sorting, Depth_First_Search, Greedy, Graph | 61 | 100.00
 | 3546 |[Equal Sum Grid Partition I](src/main/kotlin/g3501_3600/s3546_equal_sum_grid_partition_i)| Medium | Array, Matrix, Prefix_Sum, Enumeration | 7 | 82.61
@@ -2265,7 +2269,7 @@
 | 3342 |[Find Minimum Time to Reach Last Room II](src/main/kotlin/g3301_3400/s3342_find_minimum_time_to_reach_last_room_ii)| Medium | Array, Matrix, Heap_Priority_Queue, Graph, Shortest_Path | 122 | 100.00
 | 3341 |[Find Minimum Time to Reach Last Room I](src/main/kotlin/g3301_3400/s3341_find_minimum_time_to_reach_last_room_i)| Medium | Array, Matrix, Heap_Priority_Queue, Graph, Shortest_Path | 257 | 42.10
 | 3340 |[Check Balanced String](src/main/kotlin/g3301_3400/s3340_check_balanced_string)| Easy | String | 1 | 100.00
-| 3337 |[Total Characters in String After Transformations II](src/main/kotlin/g3301_3400/s3337_total_characters_in_string_after_transformations_ii)| Hard | String, Hash_Table, Dynamic_Programming, Math, Counting | 320 | 100.00
+| 3337 |[Total Characters in String After Transformations II](src/main/kotlin/g3301_3400/s3337_total_characters_in_string_after_transformations_ii)| Hard | String, Hash_Table, Dynamic_Programming, Math, Counting | 302 | 100.00
 | 3336 |[Find the Number of Subsequences With Equal GCD](src/main/kotlin/g3301_3400/s3336_find_the_number_of_subsequences_with_equal_gcd)| Hard | Array, Dynamic_Programming, Math, Number_Theory | 324 | 100.00
 | 3335 |[Total Characters in String After Transformations I](src/main/kotlin/g3301_3400/s3335_total_characters_in_string_after_transformations_i)| Medium | String, Hash_Table, Dynamic_Programming, Math, Counting | 58 | 80.00
 | 3334 |[Find the Maximum Factor Score of Array](src/main/kotlin/g3301_3400/s3334_find_the_maximum_factor_score_of_array)| Medium | Array, Math, Number_Theory | 4 | 95.83

src/main/kotlin/g3301_3400/s3337_total_characters_in_string_after_transformations_ii/readme.md

@@ -74,87 +74,70 @@ Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> +
 ```kotlin
 class Solution {
     fun lengthAfterTransformations(s: String, t: Int, nums: List<Int>): Int {
-        val m = Array<IntArray>(26) { IntArray(26) }
-        for (i in 0..25) {
-            for (j in 1..nums[i]) {
-                m[(i + j) % 26][i] = m[(i + j) % 26][i] + 1
-            }
-        }
-        var v = IntArray(26)
+        val localT = buildTransformationMatrix(nums)
+        val tPower = matrixPower(localT, t)
+        val freq = IntArray(26)
         for (c in s.toCharArray()) {
-            v[c.code - 'a'.code]++
+            freq[c.code - 'a'.code]++
         }
-        v = pow(m, v, t.toLong())
-        var ans: Long = 0
-        for (x in v) {
-            ans += x.toLong()
+        var result: Long = 0
+        for (i in 0..25) {
+            var sum: Long = 0
+            for (j in 0..25) {
+                sum = (sum + freq[j].toLong() * tPower[j][i]) % MOD
+            }
+            result = (result + sum) % MOD
         }
-        return (ans % MOD).toInt()
+        return result.toInt()
     }
 
-    // A^e*v
-    private fun pow(a: Array<IntArray>, v: IntArray, e: Long): IntArray {
-        var v = v
-        var e = e
-        for (i in v.indices) {
-            if (v[i] >= MOD) {
-                v[i] %= MOD
-            }
-        }
-        var mul = a
-        while (e > 0) {
-            if ((e and 1L) == 1L) {
-                v = mul(mul, v)
+    private fun buildTransformationMatrix(numsList: List<Int>): Array<IntArray> {
+        val localT = Array(26) { IntArray(26) }
+        for (i in 0..25) {
+            val steps: Int = numsList[i]
+            for (j in 1..steps) {
+                localT[i][(i + j) % 26] = localT[i][(i + j) % 26] + 1
             }
-            mul = p2(mul)
-            e = e ushr 1
         }
-        return v
+        return localT
     }
 
-    // int matrix*int vector
-    private fun mul(a: Array<IntArray>, v: IntArray): IntArray {
-        val m = a.size
-        val n = v.size
-        val w = IntArray(m)
-        for (i in 0 until m) {
-            var sum: Long = 0
-            for (k in 0 until n) {
-                sum += a[i][k].toLong() * v[k]
-                if (sum >= BIG) {
-                    sum -= BIG
-                }
+    private fun matrixPower(matrix: Array<IntArray>, power: Int): Array<IntArray> {
+        var matrix = matrix
+        var power = power
+        val size = matrix.size
+        var result = Array(size) { IntArray(size) }
+        for (i in 0..<size) {
+            result[i][i] = 1
+        }
+        while (power > 0) {
+            if ((power and 1) == 1) {
+                result = multiplyMatrices(result, matrix)
             }
-            w[i] = (sum % MOD).toInt()
+            matrix = multiplyMatrices(matrix, matrix)
+            power = power shr 1
         }
-        return w
+        return result
     }
 
-    // int matrix^2 (be careful about negative value)
-    private fun p2(a: Array<IntArray>): Array<IntArray> {
-        val n = a.size
-        val c = Array<IntArray>(n) { IntArray(n) }
-        for (i in 0 until n) {
-            val sum = LongArray(n)
-            for (k in 0 until n) {
-                for (j in 0 until n) {
-                    sum[j] += a[i][k].toLong() * a[k][j]
-                    if (sum[j] >= BIG) {
-                        sum[j] -= BIG
-                    }
+    private fun multiplyMatrices(a: Array<IntArray>, b: Array<IntArray>): Array<IntArray> {
+        val size = a.size
+        val result = Array(size) { IntArray(size) }
+        for (i in 0..<size) {
+            for (k in 0..<size) {
+                if (a[i][k] == 0) {
+                    continue
+                }
+                for (j in 0..<size) {
+                    result[i][j] = ((result[i][j] + a[i][k].toLong() * b[k][j]) % MOD).toInt()
                 }
-            }
-            for (j in 0 until n) {
-                c[i][j] = (sum[j] % MOD).toInt()
             }
         }
-        return c
+        return result
     }
 
     companion object {
-        const val MOD: Int = 1000000007
-        const val M2: Long = MOD.toLong() * MOD
-        const val BIG: Long = 8L * M2
+        private const val MOD = 1000000007
     }
 }
 ```

src/main/kotlin/g3501_3600/s3550_smallest_index_with_digit_sum_equal_to_index/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3550\. Smallest Index With Digit Sum Equal to Index
+
+Easy
+
+You are given an integer array `nums`.
+
+Return the **smallest** index `i` such that the sum of the digits of `nums[i]` is equal to `i`.
+
+If no such index exists, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,2]
+
+**Output:** 2
+
+**Explanation:**
+
+*   For `nums[2] = 2`, the sum of digits is 2, which is equal to index `i = 2`. Thus, the output is 2.
+
+**Example 2:**
+
+**Input:** nums = [1,10,11]
+
+**Output:** 1
+
+**Explanation:**
+
+*   For `nums[1] = 10`, the sum of digits is `1 + 0 = 1`, which is equal to index `i = 1`.
+*   For `nums[2] = 11`, the sum of digits is `1 + 1 = 2`, which is equal to index `i = 2`.
+*   Since index 1 is the smallest, the output is 1.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** \-1
+
+**Explanation:**
+
+*   Since no index satisfies the condition, the output is -1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 1000`
+
+## Solution
+
+```kotlin
+class Solution {
+    private fun sum(num: Int): Int {
+        var num = num
+        var s = 0
+        while (num > 0) {
+            s += num % 10
+            num /= 10
+        }
+        return s
+    }
+
+    fun smallestIndex(nums: IntArray): Int {
+        for (i in nums.indices) {
+            if (i == sum(nums[i])) {
+                return i
+            }
+        }
+        return -1
+    }
+}
+```

src/main/kotlin/g3501_3600/s3551_minimum_swaps_to_sort_by_digit_sum/readme.md

@@ -0,0 +1,103 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3551\. Minimum Swaps to Sort by Digit Sum
+
+Medium
+
+You are given an array `nums` of **distinct** positive integers. You need to sort the array in **increasing** order based on the sum of the digits of each number. If two numbers have the same digit sum, the **smaller** number appears first in the sorted order.
+
+Return the **minimum** number of swaps required to rearrange `nums` into this sorted order.
+
+A **swap** is defined as exchanging the values at two distinct positions in the array.
+
+**Example 1:**
+
+**Input:** nums = [37,100]
+
+**Output:** 1
+
+**Explanation:**
+
+*   Compute the digit sum for each integer: `[3 + 7 = 10, 1 + 0 + 0 = 1] → [10, 1]`
+*   Sort the integers based on digit sum: `[100, 37]`. Swap `37` with `100` to obtain the sorted order.
+*   Thus, the minimum number of swaps required to rearrange `nums` is 1.
+
+**Example 2:**
+
+**Input:** nums = [22,14,33,7]
+
+**Output:** 0
+
+**Explanation:**
+
+*   Compute the digit sum for each integer: `[2 + 2 = 4, 1 + 4 = 5, 3 + 3 = 6, 7 = 7] → [4, 5, 6, 7]`
+*   Sort the integers based on digit sum: `[22, 14, 33, 7]`. The array is already sorted.
+*   Thus, the minimum number of swaps required to rearrange `nums` is 0.
+
+**Example 3:**
+
+**Input:** nums = [18,43,34,16]
+
+**Output:** 2
+
+**Explanation:**
+
+*   Compute the digit sum for each integer: `[1 + 8 = 9, 4 + 3 = 7, 3 + 4 = 7, 1 + 6 = 7] → [9, 7, 7, 7]`
+*   Sort the integers based on digit sum: `[16, 34, 43, 18]`. Swap `18` with `16`, and swap `43` with `34` to obtain the sorted order.
+*   Thus, the minimum number of swaps required to rearrange `nums` is 2.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   `nums` consists of **distinct** positive integers.
+
+## Solution
+
+```kotlin
+class Solution {
+    private class Pair(var sum: Int, var value: Int, var index: Int)
+
+    fun minSwaps(arr: IntArray): Int {
+        val n = arr.size
+        val pairs = arrayOfNulls<Pair>(n)
+        for (i in 0..<n) {
+            var v = arr[i]
+            var s = 0
+            while (v > 0) {
+                s += v % 10
+                v /= 10
+            }
+            pairs[i] = Pair(s, arr[i], i)
+        }
+        pairs.sortWith { a, b ->
+            if (a!!.sum != b!!.sum) {
+                a.sum - b.sum
+            } else {
+                a.value - b.value
+            }
+        }
+        val posMap = IntArray(n)
+        for (i in 0..<n) {
+            posMap[i] = pairs[i]!!.index
+        }
+        val seen = BooleanArray(n)
+        var swaps = 0
+        for (i in 0..<n) {
+            if (seen[i] || posMap[i] == i) {
+                continue
+            }
+            var cycleSize = 0
+            var j = i
+            while (!seen[j]) {
+                seen[j] = true
+                j = posMap[j]
+                cycleSize++
+            }
+            swaps += cycleSize - 1
+        }
+        return swaps
+    }
+}
+```