Improved tasks 3332, 3337

Author: javadev

src/main/kotlin/g3301_3400/s3332_maximum_points_tourist_can_earn/Solution.kt

@@ -8,18 +8,18 @@ import kotlin.math.max
 class Solution {
     fun maxScore(n: Int, k: Int, stayScores: Array<IntArray>, travelScores: Array<IntArray>): Int {
         // dp[day][city]
-        val dp = Array<IntArray?>(k + 1) { IntArray(n) }
+        val dp = Array<IntArray>(k + 1) { IntArray(n) }
         var result = 0
         for (day in k - 1 downTo 0) {
             for (city in 0 until n) {
-                val stayScore = stayScores[day][city] + dp[day + 1]!![city]
+                val stayScore = stayScores[day][city] + dp[day + 1][city]
                 var travelScore = 0
                 for (nextCity in 0 until n) {
-                    val nextScore = travelScores[city][nextCity] + dp[day + 1]!![nextCity]
+                    val nextScore = travelScores[city][nextCity] + dp[day + 1][nextCity]
                     travelScore = max(nextScore, travelScore)
                 }
-                dp[day]!![city] = max(stayScore, travelScore)
-                result = max(dp[day]!![city], result)
+                dp[day][city] = max(stayScore, travelScore)
+                result = max(dp[day][city], result)
             }
         }
         return result

src/main/kotlin/g3301_3400/s3337_total_characters_in_string_after_transformations_ii/Solution.kt

@@ -5,10 +5,10 @@ package g3301_3400.s3337_total_characters_in_string_after_transformations_ii
 
 class Solution {
     fun lengthAfterTransformations(s: String, t: Int, nums: List<Int>): Int {
-        val m = Array<IntArray?>(26) { IntArray(26) }
+        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
+                m[(i + j) % 26][i] = m[(i + j) % 26][i] + 1
             }
         }
         var v = IntArray(26)
@@ -24,7 +24,7 @@ class Solution {
     }
 
     // A^e*v
-    private fun pow(a: Array<IntArray?>, v: IntArray, e: Long): IntArray {
+    private fun pow(a: Array<IntArray>, v: IntArray, e: Long): IntArray {
         var v = v
         var e = e
         for (i in v.indices) {
@@ -44,14 +44,14 @@ class Solution {
     }
 
     // int matrix*int vector
-    private fun mul(a: Array<IntArray?>, v: IntArray): IntArray {
+    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]
+                sum += a[i][k].toLong() * v[k]
                 if (sum >= BIG) {
                     sum -= BIG
                 }
@@ -62,21 +62,21 @@ class Solution {
     }
 
     // int matrix^2 (be careful about negative value)
-    private fun p2(a: Array<IntArray?>): Array<IntArray?> {
+    private fun p2(a: Array<IntArray>): Array<IntArray> {
         val n = a.size
-        val c = Array<IntArray?>(n) { IntArray(n) }
+        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]
+                    sum[j] += a[i][k].toLong() * a[k][j]
                     if (sum[j] >= BIG) {
                         sum[j] -= BIG
                     }
                 }
             }
             for (j in 0 until n) {
-                c[i]!![j] = (sum[j] % MOD).toInt()
+                c[i][j] = (sum[j] % MOD).toInt()
             }
         }
         return c