diff --git a/src/main/kotlin/g3301_3400/s3392_count_subarrays_of_length_three_with_a_condition/Solution.kt b/src/main/kotlin/g3301_3400/s3392_count_subarrays_of_length_three_with_a_condition/Solution.kt
index d2c77b3b3..5f46a884c 100644
--- a/src/main/kotlin/g3301_3400/s3392_count_subarrays_of_length_three_with_a_condition/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3392_count_subarrays_of_length_three_with_a_condition/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3392_count_subarrays_of_length_three_with_a_condition
 
-// #Easy #2024_12_22_Time_3_ms_(100.00%)_Space_45_MB_(100.00%)
+// #Easy #Array #2024_12_22_Time_3_ms_(100.00%)_Space_45_MB_(100.00%)
 
 class Solution {
     fun countSubarrays(nums: IntArray): Int {
diff --git a/src/main/kotlin/g3301_3400/s3393_count_paths_with_the_given_xor_value/Solution.kt b/src/main/kotlin/g3301_3400/s3393_count_paths_with_the_given_xor_value/Solution.kt
index b908c0e62..836942d45 100644
--- a/src/main/kotlin/g3301_3400/s3393_count_paths_with_the_given_xor_value/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3393_count_paths_with_the_given_xor_value/Solution.kt
@@ -1,6 +1,7 @@
 package g3301_3400.s3393_count_paths_with_the_given_xor_value
 
-// #Medium #2024_12_30_Time_57_(68.42%)_Space_73.12_(52.63%)
+// #Medium #Array #Dynamic_Programming #Math #Matrix #Bit_Manipulation
+// #2024_12_30_Time_57_(68.42%)_Space_73.12_(52.63%)
 
 class Solution {
     private var m = -1
diff --git a/src/main/kotlin/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.kt b/src/main/kotlin/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.kt
index cd5245c6d..a3eb74212 100644
--- a/src/main/kotlin/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.kt
@@ -1,55 +1,43 @@
 package g3301_3400.s3394_check_if_grid_can_be_cut_into_sections
 
-// #Medium #2024_12_22_Time_298_ms_(100.00%)_Space_132.4_MB_(100.00%)
+// #Medium #Geometry #Line_Sweep #2025_01_06_Time_61_(100.00%)_Space_152.17_(45.00%)
 
 import kotlin.math.max
 
 @Suppress("unused")
 class Solution {
-    fun checkValidCuts(n: Int, rectangles: Array<IntArray>): Boolean {
-        val m = rectangles.size
-        val xAxis = Array<IntArray>(m) { IntArray(2) }
-        val yAxis = Array<IntArray>(m) { IntArray(2) }
-        var ind = 0
-        for (axis in rectangles) {
-            val startX = axis[0]
-            val startY = axis[1]
-            val endX = axis[2]
-            val endY = axis[3]
-            xAxis[ind] = intArrayOf(startX, endX)
-            yAxis[ind] = intArrayOf(startY, endY)
-            ind++
+    fun checkValidCuts(m: Int, rectangles: Array<IntArray>): Boolean {
+        val n = rectangles.size
+        val start = LongArray(n)
+        for (i in 0..<n) {
+            start[i] = (rectangles[i][1].toLong() shl 32) + rectangles[i][3]
         }
-
-        xAxis.sortWith<IntArray>(
-            Comparator { a: IntArray, b: IntArray -> if (a[0] == b[0]) a[1] - b[1] else a[0] - b[0] },
-        )
-
-        yAxis.sortWith<IntArray>(
-            Comparator { a: IntArray, b: IntArray -> if (a[0] == b[0]) a[1] - b[1] else a[0] - b[0] },
-        )
-        val verticalCuts = findSections(xAxis)
-        if (verticalCuts > 2) {
+        start.sort()
+        if (validate(start)) {
             return true
         }
-        val horizontalCuts = findSections(yAxis)
-        return horizontalCuts > 2
+        for (i in 0..<n) {
+            start[i] = (rectangles[i][0].toLong() shl 32) + rectangles[i][2]
+        }
+        start.sort()
+        return validate(start)
     }
 
-    private fun findSections(axis: Array<IntArray>): Int {
-        var end = axis[0][1]
-        var sections = 1
-        for (i in 1..<axis.size) {
-            if (end > axis[i][0]) {
-                end = max(end, axis[i][1])
-            } else {
-                sections++
-                end = axis[i][1]
-            }
-            if (sections > 2) {
-                return sections
+    private fun validate(arr: LongArray): Boolean {
+        var cut = 0
+        val n = arr.size
+        var max = arr[0].toInt() and MASK
+        for (i in 0..<n) {
+            val start = (arr[i] shr 32).toInt()
+            if (start >= max && ++cut == 2) {
+                return true
             }
+            max = max(max.toDouble(), (arr[i] and MASK.toLong()).toInt().toDouble()).toInt()
         }
-        return sections
+        return false
+    }
+
+    companion object {
+        private val MASK = (1 shl 30) - 1
     }
 }
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 4f21cdd3f..1c44826bb 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
@@ -1,190 +1,74 @@
 package g3301_3400.s3395_subsequences_with_a_unique_middle_mode_i
 
-// #Hard #2024_12_22_Time_485_ms_(100.00%)_Space_50.6_MB_(100.00%)
+// #Hard #Array #Hash_Table #Math #Combinatorics #2025_01_06_Time_49_(100.00%)_Space_41.14_(100.00%)
 
 class Solution {
-    fun subsequencesWithMiddleMode(a: IntArray): Int {
-        val n = a.size
-        // Create a dictionary to store indices of each number
-        val dict: MutableMap<Int, MutableList<Int>> = HashMap()
-        for (i in 0..<n) {
-            dict.computeIfAbsent(a[i]) { _: Int -> ArrayList<Int>() }.add(i)
-        }
-        var ans = 0L
-        // Iterate over each unique number and its indices
-        for (entry in dict.entries) {
-            val b: MutableList<Int> = entry.value
-            val m = b.size
-            for (k in 0..<m) {
-                val i: Int = b[k]
-                val r = m - 1 - k
-                val u = i - k
-                val v = (n - 1 - i) - r
-                // Case 2: Frequency of occurrence is 2 times
-                ans = (
-                    ans + convert(k, 1) * convert(u, 1) % MOD * convert(
-                        v,
-                        2,
-                    ) % MOD
-                    ) % MOD
-                ans = (
-                    ans + convert(r, 1) * convert(u, 2) % MOD * convert(
-                        v,
-                        1,
-                    ) % MOD
-                    ) % MOD
-                // Case 3: Frequency of occurrence is 3 times
-                ans = (ans + convert(k, 2) * convert(v, 2) % MOD) % MOD
-                ans = (ans + convert(r, 2) * convert(u, 2) % MOD) % MOD
-                ans =
-                    (
-                        (
-                            ans +
-                                convert(k, 1) *
-                                convert(r, 1) %
-                                MOD
-                                * convert(u, 1) %
-                                MOD
-                                * convert(v, 1) %
-                                MOD
-                            ) %
-                            MOD
-                        )
-                // Case 4: Frequency of occurrence is 4 times
-                ans = (
-                    ans + convert(k, 2) * convert(r, 1) % MOD * convert(
-                        v,
-                        1,
-                    ) % MOD
-                    ) % MOD
-                ans = (
-                    ans + convert(k, 1) * convert(r, 2) % MOD * convert(
-                        u,
-                        1,
-                    ) % MOD
-                    ) % MOD
+    private val c2 = LongArray(1001)
 
-                // Case 5: Frequency of occurrence is 5 times
-                ans = (ans + convert(k, 2) * convert(r, 2) % MOD) % MOD
+    fun subsequencesWithMiddleMode(nums: IntArray): Int {
+        if (c2[2] == 0L) {
+            c2[1] = 0
+            c2[0] = c2[1]
+            c2[2] = 1
+            for (i in 3..<c2.size) {
+                c2[i] = (i * (i - 1) / 2).toLong()
             }
         }
-        var dif: Long = 0
-        // Principle of inclusion-exclusion
-        for (midEntry in dict.entries) {
-            val b: MutableList<Int> = midEntry.value
-            val m = b.size
-            for (tmpEntry in dict.entries) {
-                if (midEntry.key != tmpEntry.key) {
-                    val c: MutableList<Int> = tmpEntry.value
-                    val size = c.size
-                    var k = 0
-                    var j = 0
-                    while (k < m) {
-                        val i: Int = b[k]
-                        val r = m - 1 - k
-                        val u = i - k
-                        val v = (n - 1 - i) - r
-                        while (j < size && c[j] < i) {
-                            j++
-                        }
-                        val x = j
-                        val y = size - x
-                        dif =
-                            (
-                                (
-                                    dif +
-                                        convert(k, 1) *
-                                        convert(x, 1) %
-                                        MOD
-                                        * convert(y, 1) %
-                                        MOD
-                                        * convert(v - y, 1) %
-                                        MOD
-                                    ) %
-                                    MOD
-                                )
-                        dif =
-                            (
-                                (
-                                    dif +
-                                        convert(k, 1) *
-                                        convert(y, 2) %
-                                        MOD
-                                        * convert(u - x, 1) %
-                                        MOD
-                                    ) %
-                                    MOD
-                                )
-                        dif =
-                            (
-                                (
-                                    dif + convert(k, 1) * convert(x, 1) % MOD * convert(
-                                        y,
-                                        2,
-                                    ) % MOD
-                                    ) %
-                                    MOD
-                                )
-
-                        dif =
-                            (
-                                (
-                                    dif +
-                                        convert(r, 1) *
-                                        convert(x, 1) %
-                                        MOD
-                                        * convert(y, 1) %
-                                        MOD
-                                        * convert(u - x, 1) %
-                                        MOD
-                                    ) %
-                                    MOD
-                                )
-                        dif =
-                            (
-                                (
-                                    dif +
-                                        convert(r, 1) *
-                                        convert(x, 2) %
-                                        MOD
-                                        * convert(v - y, 1) %
-                                        MOD
-                                    ) %
-                                    MOD
-                                )
-                        dif =
-                            (
-                                (
-                                    dif + convert(r, 1) * convert(x, 2) % MOD * convert(
-                                        y,
-                                        1,
-                                    ) % MOD
-                                    ) %
-                                    MOD
-                                )
-                        k++
-                    }
-                }
+        val n = nums.size
+        val newNums = IntArray(n)
+        val map: MutableMap<Int?, Int?> = HashMap<Int?, Int?>(n)
+        var m = 0
+        var index = 0
+        for (x in nums) {
+            var id = map[x]
+            if (id == null) {
+                id = m++
+                map.put(x, id)
             }
+            newNums[index++] = id
         }
-        return ((ans - dif + MOD) % MOD).toInt()
-    }
-
-    private fun convert(n: Int, k: Int): Long {
-        if (k > n) {
+        if (m == n) {
             return 0
         }
-        if (k == 0 || k == n) {
-            return 1
+        val rightCount = IntArray(m)
+        for (x in newNums) {
+            rightCount[x]++
         }
-        var res: Long = 1
-        for (i in 0..<k) {
-            res = res * (n - i) / (i + 1)
+        val leftCount = IntArray(m)
+        var ans = n.toLong() * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 120
+        for (left in 0..<n - 2) {
+            val x = newNums[left]
+            rightCount[x]--
+            if (left >= 2) {
+                val right = n - (left + 1)
+                val leftX = leftCount[x]
+                val rightX = rightCount[x]
+                ans -= c2[left - leftX] * c2[right - rightX]
+                for (y in 0..<m) {
+                    if (y == x) {
+                        continue
+                    }
+                    val rightY = rightCount[y]
+                    val leftY = leftCount[y]
+                    ans -= c2[leftY] * rightX * (right - rightX)
+                    ans -= c2[rightY] * leftX * (left - leftX)
+                    ans -=
+                        (
+                            leftY
+                                * rightY
+                                * (
+                                    leftX * (right - rightX - rightY) +
+                                        rightX * (left - leftX - leftY)
+                                    )
+                            ).toLong()
+                }
+            }
+            leftCount[x]++
         }
-        return res % MOD
+        return (ans % MOD).toInt()
     }
 
     companion object {
-        private const val MOD = 1000000007
+        private val MOD = 1e9.toInt() + 7
     }
 }
diff --git a/src/main/kotlin/g3301_3400/s3396_minimum_number_of_operations_to_make_elements_in_array_distinct/Solution.kt b/src/main/kotlin/g3301_3400/s3396_minimum_number_of_operations_to_make_elements_in_array_distinct/Solution.kt
index 01721c5d2..77903f727 100644
--- a/src/main/kotlin/g3301_3400/s3396_minimum_number_of_operations_to_make_elements_in_array_distinct/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3396_minimum_number_of_operations_to_make_elements_in_array_distinct/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3396_minimum_number_of_operations_to_make_elements_in_array_distinct
 
-// #Easy #2024_12_22_Time_9_ms_(100.00%)_Space_37.9_MB_(100.00%)
+// #Easy #Array #Greedy #Simulation #2024_12_22_Time_9_ms_(100.00%)_Space_37.9_MB_(100.00%)
 
 import kotlin.math.min
 
diff --git a/src/main/kotlin/g3301_3400/s3397_maximum_number_of_distinct_elements_after_operations/Solution.kt b/src/main/kotlin/g3301_3400/s3397_maximum_number_of_distinct_elements_after_operations/Solution.kt
index a84a0ba55..582757802 100644
--- a/src/main/kotlin/g3301_3400/s3397_maximum_number_of_distinct_elements_after_operations/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3397_maximum_number_of_distinct_elements_after_operations/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3397_maximum_number_of_distinct_elements_after_operations
 
-// #Medium #2024_12_22_Time_517_ms_(100.00%)_Space_61.2_MB_(100.00%)
+// #Medium #Array #Sorting #Greedy #2024_12_22_Time_517_ms_(100.00%)_Space_61.2_MB_(100.00%)
 
 import kotlin.math.max
 
diff --git a/src/main/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.kt b/src/main/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.kt
index 27c850d6c..5d26bc651 100644
--- a/src/main/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3398_smallest_substring_with_identical_characters_i
 
-// #Hard #2024_12_24_Time_2_ms_(100.00%)_Space_36.4_MB_(92.86%)
+// #Hard #Array #Binary_Search #Enumeration #2024_12_24_Time_2_ms_(100.00%)_Space_36.4_MB_(92.86%)
 
 class Solution {
     fun minLength(s: String, ops: Int): Int {
diff --git a/src/main/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.kt b/src/main/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.kt
index d96f624e7..4127052cb 100644
--- a/src/main/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.kt
+++ b/src/main/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3399_smallest_substring_with_identical_characters_ii
 
-// #Hard #2024_12_24_Time_26_ms_(100.00%)_Space_40.2_MB_(100.00%)
+// #Hard #Bit_Manipulation #Sliding_Window #2024_12_24_Time_26_ms_(100.00%)_Space_40.2_MB_(100.00%)
 
 import kotlin.math.max
 import kotlin.math.min
diff --git a/src/main/kotlin/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/Solution.kt b/src/main/kotlin/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/Solution.kt
index f386ad3ba..69cc1f92b 100644
--- a/src/main/kotlin/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/Solution.kt
+++ b/src/main/kotlin/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3402_minimum_operations_to_make_columns_strictly_increasing
 
-// #Easy #2024_12_29_Time_1_(100.00%)_Space_44.94_(100.00%)
+// #Easy #Matrix #Simulation #2024_12_29_Time_1_(100.00%)_Space_44.94_(100.00%)
 
 class Solution {
     fun minimumOperations(grid: Array<IntArray>): Int {
diff --git a/src/main/kotlin/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/Solution.kt b/src/main/kotlin/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/Solution.kt
index 1d38bf7ec..933cbce4a 100644
--- a/src/main/kotlin/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/Solution.kt
+++ b/src/main/kotlin/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3403_find_the_lexicographically_largest_string_from_the_box_i
 
-// #Medium #2024_12_29_Time_22_(100.00%)_Space_38.72_(100.00%)
+// #Medium #String #Two_Pointers #Enumeration #2024_12_29_Time_22_(100.00%)_Space_38.72_(100.00%)
 
 import kotlin.math.min
 
diff --git a/src/main/kotlin/g3401_3500/s3404_count_special_subsequences/Solution.kt b/src/main/kotlin/g3401_3500/s3404_count_special_subsequences/Solution.kt
index b55ff4356..d59c552d8 100644
--- a/src/main/kotlin/g3401_3500/s3404_count_special_subsequences/Solution.kt
+++ b/src/main/kotlin/g3401_3500/s3404_count_special_subsequences/Solution.kt
@@ -1,6 +1,7 @@
 package g3401_3500.s3404_count_special_subsequences
 
-// #Medium #2024_12_29_Time_276_(100.00%)_Space_60.90_(100.00%)
+// #Medium #Array #Hash_Table #Math #Enumeration
+// #2024_12_29_Time_276_(100.00%)_Space_60.90_(100.00%)
 
 class Solution {
     fun numberOfSubsequences(nums: IntArray): Long {
diff --git a/src/main/kotlin/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/Solution.kt b/src/main/kotlin/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/Solution.kt
index 53aa6c48f..afb467879 100644
--- a/src/main/kotlin/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/Solution.kt
+++ b/src/main/kotlin/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements
 
-// #Hard #2024_12_29_Time_57_(100.00%)_Space_37.63_(100.00%)
+// #Hard #Math #Combinatorics #2024_12_29_Time_57_(100.00%)_Space_37.63_(100.00%)
 
 class Solution {
     fun countGoodArrays(n: Int, m: Int, k: Int): Int {