Added tags

Author: javadev

src/main/kotlin/g3101_3200/s3184_count_pairs_that_form_a_complete_day_i/Solution.kt

@@ -1,6 +1,6 @@
 package g3101_3200.s3184_count_pairs_that_form_a_complete_day_i
 
-// #Easy #Array #Hash_Table #Counting #2024_06_21_Time_1_ms_(98.20%)_Space_42_MB_(83.72%)
+// #Easy #Array #Hash_Table #Counting #2024_06_22_Time_171_ms_(68.42%)_Space_35.1_MB_(91.58%)
 
 class Solution {
     fun countCompleteDayPairs(hours: IntArray): Int {

src/main/kotlin/g3101_3200/s3185_count_pairs_that_form_a_complete_day_ii/Solution.kt

@@ -1,6 +1,6 @@
 package g3101_3200.s3185_count_pairs_that_form_a_complete_day_ii
 
-// #Medium #Array #Hash_Table #Counting #2024_06_21_Time_3_ms_(97.60%)_Space_97.1_MB_(14.69%)
+// #Medium #Array #Hash_Table #Counting #2024_06_22_Time_578_ms_(78.33%)_Space_115_MB_(66.67%)
 
 class Solution {
     fun countCompleteDayPairs(hours: IntArray): Long {

src/main/kotlin/g3101_3200/s3186_maximum_total_damage_with_spell_casting/Solution.kt

@@ -24,10 +24,9 @@ class Solution {
         }
         val dp = LongArray(maxPower + 6)
         dp[1] = counts[1].toLong()
-        dp[2] = max((counts[2] * 2L).toDouble(), dp[1].toDouble()).toLong()
+        dp[2] = max((counts[2] * 2L), dp[1])
         for (i in 3..maxPower) {
-            dp[i] = max((counts[i] * i + dp[i - 3]).toDouble(), max(dp[i - 1].toDouble(), dp[i - 2].toDouble()))
-                .toLong()
+            dp[i] = max((counts[i] * i + dp[i - 3]), max(dp[i - 1], dp[i - 2]))
         }
         return dp[maxPower]
     }
@@ -45,15 +44,12 @@ class Solution {
                 count++
             } else {
                 val curVal = max(
-                    (curPower.toLong() * count + prevs[3]).toDouble(),
-                    max(prevs[1].toDouble(), prevs[2].toDouble())
+                    (curPower * count + prevs[3]),
+                    max(prevs[1], prevs[2])
                 )
-                    .toLong()
-                val diff = min((p - curPower).toDouble(), (prevs.size - 1).toDouble()).toInt()
+                val diff = min((p - curPower), (prevs.size - 1))
                 val nextCurVal =
-                    if ((diff == 1)) 0 else max(prevs[3].toDouble(), max(curVal.toDouble(), prevs[2].toDouble()))
-                        .toLong()
-                // Shift the values in prevs[].
+                    if ((diff == 1)) 0 else max(prevs[3], max(curVal, prevs[2]))
                 var k = prevs.size - 1
                 if (diff < prevs.size - 1) {
                     while (k > diff) {

src/main/kotlin/g3101_3200/s3187_peaks_in_array/Solution.kt

@@ -1,6 +1,7 @@
 package g3101_3200.s3187_peaks_in_array
 
-// #2024_06_21_Time_18_ms_(100.00%)_Space_137.7_MB_(31.34%)
+// #Hard #Array #Segment_Tree #Binary_Indexed_Tree
+// #2024_06_22_Time_1339_ms_(80.00%)_Space_135.1_MB_(70.00%)
 
 import kotlin.math.max
 
@@ -10,12 +11,11 @@ class Solution {
         val peaks = BooleanArray(nums.size)
         val binaryIndexedTree = IntArray(Integer.highestOneBit(peaks.size) * 2 + 1)
         for (i in 1 until peaks.size - 1) {
-            if (nums[i] > max(nums[i - 1].toDouble(), nums[i + 1].toDouble())) {
+            if (nums[i] > max(nums[i - 1], nums[i + 1])) {
                 peaks[i] = true
                 update(binaryIndexedTree, i + 1, 1)
             }
         }
-
         val result: MutableList<Int> = ArrayList()
         for (query in queries) {
             if (query[0] == 1) {
@@ -30,7 +30,7 @@ class Solution {
                     val affected = index + i
                     if (affected >= 1 && affected <= nums.size - 2) {
                         val peak =
-                            nums[affected] > max(nums[affected - 1].toDouble(), nums[affected + 1].toDouble())
+                            nums[affected] > max(nums[affected - 1], nums[affected + 1])
                         if (peak != peaks[affected]) {
                             if (peak) {
                                 update(binaryIndexedTree, affected + 1, 1)
@@ -47,8 +47,7 @@ class Solution {
     }
 
     private fun computeRangeSum(binaryIndexedTree: IntArray, beginIndex: Int, endIndex: Int): Int {
-        return if ((beginIndex <= endIndex)
-        ) (query(binaryIndexedTree, endIndex) - query(binaryIndexedTree, beginIndex - 1))
+        return if (beginIndex <= endIndex) query(binaryIndexedTree, endIndex) - query(binaryIndexedTree, beginIndex - 1)
         else 0
     }