Improved tasks

Author: javadev

src/main/kotlin/g1501_1600/s1594_maximum_non_negative_product_in_a_matrix/Solution.kt

@@ -6,43 +6,38 @@ package g1501_1600.s1594_maximum_non_negative_product_in_a_matrix
 class Solution {
     private class Tuple(var max: Long, var min: Long)
 
-    fun maxProductPath(grid: Array<IntArray?>?): Int {
+    fun maxProductPath(grid: Array<IntArray>): Int {
         // DP
-        if (grid == null || grid.size == 0 || grid[0] == null || grid[0]!!.size == 0) {
+        if (grid.isEmpty() || grid[0].isEmpty()) {
             return 0
         }
         val rows = grid.size
-        val cols = grid[0]!!.size
-        val dp = Array(rows) { arrayOfNulls<Tuple>(cols) }
-        for (i in 0 until rows) {
-            for (j in 0 until cols) {
-                dp[i][j] = Tuple(1, 1)
-            }
-        }
+        val cols = grid[0].size
+        val dp = Array(rows) { Array(cols) {Tuple(1, 1)} }
         // Init first row and column
-        dp[0][0]!!.max = grid[0]!![0].toLong()
-        dp[0][0]!!.min = grid[0]!![0].toLong()
+        dp[0][0].max = grid[0][0].toLong()
+        dp[0][0].min = grid[0][0].toLong()
         for (i in 1 until rows) {
-            dp[i][0]!!.max = grid[i]!![0] * dp[i - 1][0]!!.max
-            dp[i][0]!!.min = grid[i]!![0] * dp[i - 1][0]!!.min
+            dp[i][0].max = grid[i][0] * dp[i - 1][0].max
+            dp[i][0].min = grid[i][0] * dp[i - 1][0].min
         }
         for (i in 1 until cols) {
-            dp[0][i]!!.max = grid[0]!![i] * dp[0][i - 1]!!.max
-            dp[0][i]!!.min = grid[0]!![i] * dp[0][i - 1]!!.min
+            dp[0][i].max = grid[0][i] * dp[0][i - 1].max
+            dp[0][i].min = grid[0][i] * dp[0][i - 1].min
         }
         // DP
         for (i in 1 until rows) {
             for (j in 1 until cols) {
-                val up1 = dp[i - 1][j]!!.max * grid[i]!![j]
-                val up2 = dp[i - 1][j]!!.min * grid[i]!![j]
-                val left1 = dp[i][j - 1]!!.max * grid[i]!![j]
-                val left2 = dp[i][j - 1]!!.min * grid[i]!![j]
-                dp[i][j]!!.max = Math.max(up1, Math.max(up2, Math.max(left1, left2)))
-                dp[i][j]!!.min = Math.min(up1, Math.min(up2, Math.min(left1, left2)))
+                val up1 = dp[i - 1][j].max * grid[i][j]
+                val up2 = dp[i - 1][j].min * grid[i][j]
+                val left1 = dp[i][j - 1].max * grid[i][j]
+                val left2 = dp[i][j - 1].min * grid[i][j]
+                dp[i][j].max = Math.max(up1, Math.max(up2, Math.max(left1, left2)))
+                dp[i][j].min = Math.min(up1, Math.min(up2, Math.min(left1, left2)))
             }
         }
-        return if (dp[rows - 1][cols - 1]!!.max < 0) {
+        return if (dp[rows - 1][cols - 1].max < 0) {
             -1
-        } else (dp[rows - 1][cols - 1]!!.max % (1e9 + 7)).toInt()
+        } else (dp[rows - 1][cols - 1].max % (1e9 + 7)).toInt()
     }
 }

src/main/kotlin/g2201_2300/s2286_booking_concert_tickets_in_groups/BookMyShow.kt

@@ -4,6 +4,7 @@ package g2201_2300.s2286_booking_concert_tickets_in_groups
 // #2023_06_28_Time_1292_ms_(100.00%)_Space_98.3_MB_(100.00%)
 
 import java.util.ArrayDeque
+import java.util.Arrays
 import java.util.Deque
 
 @Suppress("NAME_SHADOWING")
@@ -34,8 +35,8 @@ class BookMyShow(n: Int, private val m: Int) {
         numZerosLeft = IntArray(this.n + 2)
         // initialize max and total, for max we firstly set values to m
         // segments of size 1 are placed starting from this.n - 1
-        max.fill(this.n - 1, this.n + n - 1, m)
-        total.fill((this.n - 1).toLong(), this.n + n - 1, m)
+        Arrays.fill(max, this.n - 1, this.n + n - 1, m)
+        Arrays.fill(total, this.n - 1, this.n + n - 1, m.toLong())
         // calculate values of max and total for segments based on values of their children
         var i = this.n - 2
         var i1 = i * 2 + 1

src/main/kotlin/g3001_3100/s3068_find_the_maximum_sum_of_node_values/Solution.kt

@@ -9,7 +9,7 @@ import kotlin.math.min
 
 @Suppress("UNUSED_PARAMETER")
 class Solution {
-    fun maximumValueSum(nums: IntArray, k: Int, edges: Array<IntArray?>?): Long {
+    fun maximumValueSum(nums: IntArray, k: Int, edges: Array<IntArray>): Long {
         var res: Long = 0
         var d = 1 shl 30
         var c = 0