From e1b3a55fff2e1bf717017ae7bc44907d89716acf Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Fri, 7 Mar 2025 10:01:57 +0200
Subject: [PATCH] Improved tasks 3366, 3372, 3373, 3375, 3380, 3382, 3387, 3395

---
 .../s3366_minimum_array_sum/Solution.kt       |  8 +--
 .../Solution.kt                               | 49 +++++++++----------
 .../Solution.kt                               | 20 ++++----
 .../Solution.kt                               |  4 +-
 .../Solution.kt                               |  2 +-
 .../Solution.kt                               |  4 +-
 .../Solution.kt                               | 32 ++++++------
 .../Solution.kt                               |  6 +--
 8 files changed, 61 insertions(+), 64 deletions(-)

diff --git a/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt b/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt
index 6ce986d69..d27394f0b 100644
--- a/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt
@@ -20,13 +20,13 @@ class Solution {
                 op2--
             }
         }
-        val count: MutableMap<Int?, Int?> = HashMap<Int?, Int?>()
+        val count: MutableMap<Int, Int> = HashMap<Int, Int>()
         var odd = 0
         for (i in low..<high) {
             if (op2 > 0) {
                 nums[i] -= k
                 if (k % 2 > 0 && nums[i] % 2 > 0) {
-                    count.merge(nums[i], 1) { a: Int?, b: Int? -> Integer.sum(a!!, b!!) }
+                    count.merge(nums[i], 1) { a: Int, b: Int -> Integer.sum(a, b) }
                 }
                 op2--
             } else {
@@ -40,8 +40,8 @@ class Solution {
             while (i < high && odd > 0) {
                 val x = nums[i]
                 if (count.containsKey(x)) {
-                    if (count.merge(x, -1) { a: Int?, b: Int? ->
-                            Integer.sum(a!!, b!!)
+                    if (count.merge(x, -1) { a: Int, b: Int ->
+                            Integer.sum(a, b)
                         } == 0
                     ) {
                         count.remove(x)
diff --git a/src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.kt b/src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.kt
index a5f627c96..0c7f4bdda 100644
--- a/src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.kt
@@ -6,70 +6,67 @@ package g3301_3400.s3372_maximize_the_number_of_target_nodes_after_connecting_tr
 import kotlin.math.max
 
 class Solution {
-    private fun getGraph(edges: Array<IntArray>): Array<ArrayList<Int?>?> {
+    private fun getGraph(edges: Array<IntArray>): Array<ArrayList<Int>> {
         val n = edges.size + 1
-        val graph: Array<ArrayList<Int?>?> = arrayOfNulls<ArrayList<Int?>?>(n)
-        for (i in 0..<n) {
-            graph[i] = ArrayList<Int?>()
-        }
+        val graph: Array<ArrayList<Int>> = Array<ArrayList<Int>>(n) { ArrayList<Int>() }
         for (edge in edges) {
             val u = edge[0]
             val v = edge[1]
-            graph[u]!!.add(v)
-            graph[v]!!.add(u)
+            graph[u].add(v)
+            graph[v].add(u)
         }
         return graph
     }
 
-    private fun dfs(graph: Array<ArrayList<Int?>?>, u: Int, pt: Int, dp: Array<IntArray?>, k: Int) {
-        for (v in graph[u]!!) {
+    private fun dfs(graph: Array<ArrayList<Int>>, u: Int, pt: Int, dp: Array<IntArray>, k: Int) {
+        for (v in graph[u]) {
             if (v == pt) {
                 continue
             }
-            dfs(graph, v!!, u, dp, k)
+            dfs(graph, v, u, dp, k)
             for (i in 0..<k) {
-                dp[u]!![i + 1] += dp[v]!![i]
+                dp[u][i + 1] += dp[v][i]
             }
         }
-        dp[u]!![0] = dp[u]!![0] + 1
+        dp[u][0] = dp[u][0] + 1
     }
 
     private fun dfs2(
-        graph: Array<ArrayList<Int?>?>,
+        graph: Array<ArrayList<Int>>,
         u: Int,
         pt: Int,
         ptv: IntArray,
-        fdp: Array<IntArray?>,
-        dp: Array<IntArray?>,
+        fdp: Array<IntArray>,
+        dp: Array<IntArray>,
         k: Int,
     ) {
-        fdp[u]!![0] = dp[u]!![0]
+        fdp[u][0] = dp[u][0]
         for (i in 1..k) {
-            fdp[u]!![i] = (dp[u]!![i] + ptv[i - 1])
+            fdp[u][i] = (dp[u][i] + ptv[i - 1])
         }
-        for (v in graph[u]!!) {
+        for (v in graph[u]) {
             if (v == pt) {
                 continue
             }
             val nptv = IntArray(k + 1)
             for (i in 0..<k) {
-                nptv[i + 1] = dp[u]!![i + 1] - dp[v!!]!![i] + ptv[i]
+                nptv[i + 1] = dp[u][i + 1] - dp[v][i] + ptv[i]
             }
             nptv[0] = 1
-            dfs2(graph, v!!, u, nptv, fdp, dp, k)
+            dfs2(graph, v, u, nptv, fdp, dp, k)
         }
     }
 
-    private fun get(edges: Array<IntArray>, k: Int): Array<IntArray?> {
+    private fun get(edges: Array<IntArray>, k: Int): Array<IntArray> {
         val graph = getGraph(edges)
         val n = graph.size
-        val dp = Array<IntArray?>(n) { IntArray(k + 1) }
-        val fdp = Array<IntArray?>(n) { IntArray(k + 1) }
+        val dp = Array<IntArray>(n) { IntArray(k + 1) }
+        val fdp = Array<IntArray>(n) { IntArray(k + 1) }
         dfs(graph, 0, -1, dp, k)
         dfs2(graph, 0, -1, IntArray(k + 1), fdp, dp, k)
         for (i in 0..<n) {
             for (j in 1..k) {
-                fdp[i]!![j] += fdp[i]!![j - 1]
+                fdp[i][j] += fdp[i][j - 1]
             }
         }
         return fdp
@@ -85,12 +82,12 @@ class Solution {
         run {
             var i = 0
             while (k != 0 && i < m) {
-                max = max(max.toDouble(), b[i]!![k - 1].toDouble()).toInt()
+                max = max(max.toDouble(), b[i][k - 1].toDouble()).toInt()
                 i++
             }
         }
         for (i in 0..<n) {
-            ans[i] = a[i]!![k] + max
+            ans[i] = a[i][k] + max
         }
         return ans
     }
diff --git a/src/main/kotlin/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.kt b/src/main/kotlin/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.kt
index 42494a4d7..0d33770aa 100644
--- a/src/main/kotlin/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.kt
@@ -14,22 +14,22 @@ class Solution {
         val p2 = parents(g2)
         val eo2 = IntArray(2)
         for (i in 0..<m) {
-            eo2[p2[2]!![i] % 2]++
+            eo2[p2[2][i] % 2]++
         }
         val max = max(eo2[0], eo2[1])
         val p1 = parents(g1)
         val eo1 = IntArray(2)
         for (i in 0..<n) {
-            eo1[p1[2]!![i] % 2]++
+            eo1[p1[2][i] % 2]++
         }
         val ans = IntArray(n)
         for (i in 0..<n) {
-            ans[i] = eo1[p1[2]!![i] % 2] + max
+            ans[i] = eo1[p1[2][i] % 2] + max
         }
         return ans
     }
 
-    private fun parents(g: Array<IntArray?>): Array<IntArray?> {
+    private fun parents(g: Array<IntArray>): Array<IntArray> {
         val n = g.size
         val par = IntArray(n)
         par.fill(-1)
@@ -41,7 +41,7 @@ class Solution {
         var r = 1
         while (p < r) {
             val cur = q[p]
-            for (nex in g[cur]!!) {
+            for (nex in g[cur]) {
                 if (par[cur] != nex) {
                     q[r++] = nex
                     par[nex] = cur
@@ -50,11 +50,11 @@ class Solution {
             }
             p++
         }
-        return arrayOf<IntArray?>(par, q, depth)
+        return arrayOf<IntArray>(par, q, depth)
     }
 
-    private fun packU(n: Int, ft: Array<IntArray>): Array<IntArray?> {
-        val g = arrayOfNulls<IntArray>(n)
+    private fun packU(n: Int, ft: Array<IntArray>): Array<IntArray> {
+        val g = Array<IntArray>(n) { IntArray(0) }
         val p = IntArray(n)
         for (u in ft) {
             p[u[0]]++
@@ -64,8 +64,8 @@ class Solution {
             g[i] = IntArray(p[i])
         }
         for (u in ft) {
-            g[u[0]]!![--p[u[0]]] = u[1]
-            g[u[1]]!![--p[u[1]]] = u[0]
+            g[u[0]][--p[u[0]]] = u[1]
+            g[u[1]][--p[u[1]]] = u[0]
         }
         return g
     }
diff --git a/src/main/kotlin/g3301_3400/s3375_minimum_operations_to_make_array_values_equal_to_k/Solution.kt b/src/main/kotlin/g3301_3400/s3375_minimum_operations_to_make_array_values_equal_to_k/Solution.kt
index 77b7c616d..1c497f344 100644
--- a/src/main/kotlin/g3301_3400/s3375_minimum_operations_to_make_array_values_equal_to_k/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3375_minimum_operations_to_make_array_values_equal_to_k/Solution.kt
@@ -4,13 +4,13 @@ package g3301_3400.s3375_minimum_operations_to_make_array_values_equal_to_k
 
 class Solution {
     fun minOperations(nums: IntArray, k: Int): Int {
-        val s: MutableSet<Int?> = HashSet<Int?>()
+        val s: MutableSet<Int> = HashSet<Int>()
         for (i in nums) {
             s.add(i)
         }
         var res = 0
         for (i in s) {
-            if (i!! > k) {
+            if (i > k) {
                 res++
             } else if (i < k) {
                 return -1
diff --git a/src/main/kotlin/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/Solution.kt b/src/main/kotlin/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/Solution.kt
index 1187e08ad..7528d67d9 100644
--- a/src/main/kotlin/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/Solution.kt
@@ -8,7 +8,7 @@ import kotlin.math.min
 
 class Solution {
     fun maxRectangleArea(points: Array<IntArray>): Int {
-        val set: MutableSet<String?> = HashSet<String?>()
+        val set: MutableSet<String> = HashSet<String>()
         for (p in points) {
             set.add(p.contentToString())
         }
diff --git a/src/main/kotlin/g3301_3400/s3382_maximum_area_rectangle_with_point_constraints_ii/Solution.kt b/src/main/kotlin/g3301_3400/s3382_maximum_area_rectangle_with_point_constraints_ii/Solution.kt
index 76d4ff3b3..9aded6957 100644
--- a/src/main/kotlin/g3301_3400/s3382_maximum_area_rectangle_with_point_constraints_ii/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3382_maximum_area_rectangle_with_point_constraints_ii/Solution.kt
@@ -13,8 +13,8 @@ class Solution {
         }
         val pair = xCoord.zip(yCoord) { x, y -> Pair(x, y) }.toTypedArray()
         pair.sort()
-        val map = HashMap<Int?, Pair>()
-        val yVals = TreeSet<Int?>()
+        val map = HashMap<Int, Pair>()
+        val yVals = TreeSet<Int>()
         var best: Long = -1
         for (i in 0..<pair.size - 1) {
             if (yVals.isNotEmpty()) {
diff --git a/src/main/kotlin/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/Solution.kt b/src/main/kotlin/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/Solution.kt
index 11c7aac6e..69d601531 100644
--- a/src/main/kotlin/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/Solution.kt
@@ -7,8 +7,8 @@ import kotlin.math.max
 
 class Solution {
     private var res = 0.0
-    private var map1: MutableMap<String, MutableList<Pair>>? = null
-    private var map2: MutableMap<String, MutableList<Pair>>? = null
+    private lateinit var map1: MutableMap<String, MutableList<Pair>>
+    private lateinit var map2: MutableMap<String, MutableList<Pair>>
 
     private class Pair(var tarcurr: String, var rate: Double)
 
@@ -26,9 +26,9 @@ class Solution {
             }
         }
         val list: MutableList<Pair> = if (day == 1) {
-            map1!!.getOrDefault(currCurrency, ArrayList<Pair>())
+            map1.getOrDefault(currCurrency, ArrayList<Pair>())
         } else {
-            map2!!.getOrDefault(currCurrency, ArrayList<Pair>())
+            map2.getOrDefault(currCurrency, ArrayList<Pair>())
         }
         for (p in list) {
             if (used.add(p.tarcurr)) {
@@ -55,28 +55,28 @@ class Solution {
             val curr = pairs1[i]
             val c1 = curr[0]
             val c2 = curr[1]
-            if (!map1!!.containsKey(c1)) {
-                map1!!.put(c1, ArrayList<Pair>())
+            if (!map1.containsKey(c1)) {
+                map1.put(c1, ArrayList<Pair>())
             }
-            map1!![c1]!!.add(Pair(c2, rates1[i]))
-            if (!map1!!.containsKey(c2)) {
-                map1!!.put(c2, ArrayList<Pair>())
+            map1[c1]!!.add(Pair(c2, rates1[i]))
+            if (!map1.containsKey(c2)) {
+                map1.put(c2, ArrayList<Pair>())
             }
-            map1!![c2]!!.add(Pair(c1, 1.0 / rates1[i]))
+            map1[c2]!!.add(Pair(c1, 1.0 / rates1[i]))
         }
         size = pairs2.size
         for (i in 0..<size) {
             val curr = pairs2[i]
             val c1 = curr[0]
             val c2 = curr[1]
-            if (!map2!!.containsKey(c1)) {
-                map2!!.put(c1, ArrayList<Pair>())
+            if (!map2.containsKey(c1)) {
+                map2.put(c1, ArrayList<Pair>())
             }
-            map2!![c1]!!.add(Pair(c2, rates2[i]))
-            if (!map2!!.containsKey(c2)) {
-                map2!!.put(c2, ArrayList<Pair>())
+            map2[c1]!!.add(Pair(c2, rates2[i]))
+            if (!map2.containsKey(c2)) {
+                map2.put(c2, ArrayList<Pair>())
             }
-            map2!![c2]!!.add(Pair(c1, 1.0 / rates2[i]))
+            map2[c2]!!.add(Pair(c1, 1.0 / rates2[i]))
         }
         res = 1.0
         solve(initialCurrency, 1.0, initialCurrency, 1, HashSet<String?>())
diff --git a/src/main/kotlin/g3301_3400/s3395_subsequences_with_a_unique_middle_mode_i/Solution.kt b/src/main/kotlin/g3301_3400/s3395_subsequences_with_a_unique_middle_mode_i/Solution.kt
index cd47ffa67..d962f6b4c 100644
--- a/src/main/kotlin/g3301_3400/s3395_subsequences_with_a_unique_middle_mode_i/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3395_subsequences_with_a_unique_middle_mode_i/Solution.kt
@@ -8,8 +8,8 @@ class Solution {
 
     fun subsequencesWithMiddleMode(nums: IntArray): Int {
         if (c2[2] == 0L) {
+            c2[0] = 0
             c2[1] = 0
-            c2[0] = c2[1]
             c2[2] = 1
             for (i in 3..<c2.size) {
                 c2[i] = (i * (i - 1) / 2).toLong()
@@ -17,7 +17,7 @@ class Solution {
         }
         val n = nums.size
         val newNums = IntArray(n)
-        val map: MutableMap<Int?, Int?> = HashMap<Int?, Int?>(n)
+        val map: MutableMap<Int, Int> = HashMap<Int, Int>(n)
         var m = 0
         var index = 0
         for (x in nums) {
@@ -70,6 +70,6 @@ class Solution {
     }
 
     companion object {
-        private val MOD = 1e9.toInt() + 7
+        private const val MOD = 1e9.toInt() + 7
     }
 }