Updated tags

Author: javadev

src/main/kotlin/g3601_3700/s3618_split_array_by_prime_indices/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3618_split_array_by_prime_indices
 
-// #Medium #2025_07_20_Time_3_ms_(100.00%)_Space_62.52_MB_(100.00%)
+// #Medium #Biweekly_Contest_161 #2025_07_22_Time_6_ms_(100.00%)_Space_78.20_MB_(81.48%)
 
 import kotlin.math.abs
 

src/main/kotlin/g3601_3700/s3619_count_islands_with_total_value_divisible_by_k/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3619_count_islands_with_total_value_divisible_by_k
 
-// #Medium #2025_07_20_Time_16_ms_(96.67%)_Space_70.90_MB_(100.00%)
+// #Medium #Biweekly_Contest_161 #2025_07_22_Time_14_ms_(100.00%)_Space_86.20_MB_(47.83%)
 
 class Solution {
     private var m = 0

src/main/kotlin/g3601_3700/s3620_network_recovery_pathways/Solution.kt

@@ -1,48 +1,100 @@
 package g3601_3700.s3620_network_recovery_pathways
 
-// #Hard #2025_07_20_Time_18_ms_(100.00%)_Space_120.24_MB_(100.00%)
+// #Hard #Biweekly_Contest_161 #2025_07_22_Time_212_ms_(66.67%)_Space_150.09_MB_(13.33%)
 
 import kotlin.math.max
-import kotlin.math.min
 
 class Solution {
-    private var ans = -1
-    private var d = 0
-    private var k: Long = 0
-
-    fun findMaxPathScore(edges: Array<IntArray>, online: BooleanArray, k: Long): Int {
-        val n = online.size
-        this.k = k
-        this.d = n - 1
-        val g: Array<ArrayList<P>> = Array(n) { ArrayList() }
-        for (i in edges) {
-            if (online[i[0]] && online[i[1]]) {
-                g[i[0]].add(P(i[1], i[2]))
+    private fun topologicalSort(n: Int, g: List<List<Int>>): List<Int> {
+        val indeg = IntArray(n)
+        for (i in 0 until n) {
+            for (adjNode in g[i]) {
+                indeg[adjNode]++
             }
         }
-        dfs(g, 0, 0L, Int.Companion.MAX_VALUE)
-        return ans
-    }
-
-    private fun dfs(g: Array<ArrayList<P>>, s: Int, tc: Long, max: Int) {
-        if (s == d) {
-            if (ans == -1) {
-                ans = max
-            } else {
-                ans = max(ans, max)
+        val q: Queue<Int> = LinkedList()
+        val ts = ArrayList<Int>()
+        for (i in 0 until n) {
+            if (indeg[i] == 0) {
+                q.offer(i)
             }
-            return
         }
-        for (i in g[s]) {
-            val cost = tc + i.c
-            if (ans != -1 && ans >= max) {
-                return
+        while (!q.isEmpty()) {
+            val u = q.poll()
+            ts.add(u)
+            for (v in g[u]) {
+                indeg[v]--
+                if (indeg[v] == 0) {
+                    q.offer(v)
+                }
             }
-            if (cost <= k) {
-                dfs(g, i.d, cost, min(max, i.c))
+        }
+        return ts
+    }
+
+    private fun check(
+        x: Int,
+        n: Int,
+        adj: List<List<IntArray>>,
+        ts: List<Int>,
+        online: BooleanArray,
+        k: Long,
+    ): Boolean {
+        val d = LongArray(n)
+        Arrays.fill(d, Long.MAX_VALUE)
+        d[0] = 0
+        for (u in ts) {
+            if (d[u] != Long.MAX_VALUE) {
+                for (p in adj[u]) {
+                    val v = p[0]
+                    val c = p[1]
+                    if (c < x || !online[v]) {
+                        continue
+                    }
+                    if (d[u] + c < d[v]) {
+                        d[v] = d[u] + c
+                    }
+                }
             }
         }
+        return d[n - 1] <= k
     }
 
-    private class P(var d: Int, var c: Int)
+    fun findMaxPathScore(edges: Array<IntArray>, online: BooleanArray, k: Long): Int {
+        val n = online.size
+        // Adjacency list for graph with edge weights
+        val adj = ArrayList<ArrayList<IntArray>>()
+        for (i in 0 until n) {
+            adj.add(ArrayList())
+        }
+        val g = ArrayList<ArrayList<Int>>()
+        for (i in 0 until n) {
+            g.add(ArrayList())
+        }
+        for (e in edges) {
+            val u = e[0]
+            val v = e[1]
+            val c = e[2]
+            adj[u].add(intArrayOf(v, c))
+            g[u].add(v)
+        }
+        val ts = topologicalSort(n, g)
+        if (!check(0, n, adj, ts, online, k)) {
+            return -1
+        }
+        var l = 0
+        var h = 0
+        for (e in edges) {
+            h = max(h, e[2])
+        }
+        while (l < h) {
+            val md = l + (h - l + 1) / 2
+            if (check(md, n, adj, ts, online, k)) {
+                l = md
+            } else {
+                h = md - 1
+            }
+        }
+        return l
+    }
 }

src/main/kotlin/g3601_3700/s3621_number_of_integers_with_popcount_depth_equal_to_k_i/Solution.kt

@@ -1,71 +1,56 @@
 package g3601_3700.s3621_number_of_integers_with_popcount_depth_equal_to_k_i
 
-// #Hard #2025_07_20_Time_1_ms_(100.00%)_Space_41.10_MB_(100.00%)
+// #Hard #Biweekly_Contest_161 #2025_07_22_Time_2_ms_(100.00%)_Space_41.19_MB_(100.00%)
 
 class Solution {
-    private val slct = Array<LongArray>(MX_LN) { LongArray(MX_LN) }
-    private val popHeight = IntArray(MX_LN)
+    companion object {
+        private val comb = Array(61) { LongArray(61) }
+        private val depth = IntArray(61)
 
-    init {
-        for (i in 0..<MX_LN) {
-            slct[i][i] = 1
-            slct[i][0] = slct[i][i]
-            for (j in 1..<i) {
-                slct[i][j] = slct[i - 1][j - 1] + slct[i - 1][j]
+        init {
+            for (i in 0..60) {
+                comb[i][0] = 1L
+                comb[i][i] = 1L
+                for (j in 1 until i) {
+                    comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j]
+                }
+            }
+            depth[1] = 0
+            for (i in 2..60) {
+                depth[i] = depth[i.countOneBits()] + 1
             }
-        }
-        popHeight[1] = 0
-        for (v in 2..<MX_LN) {
-            popHeight[v] = 1 + popHeight[java.lang.Long.bitCount(v.toLong())]
         }
     }
 
-    private fun countNumbers(upperLimit: Long, setBits: Int): Long {
-        if (setBits == 0) {
-            return 1
-        }
-        var count: Long = 0
-        var used = 0
-        var len = 0
-        var x = upperLimit
-        while (x > 0) {
-            len++
-            x = x shr 1
-        }
-        for (pos in len - 1 downTo 0) {
-            if (((upperLimit shr pos) and 1L) == 1L) {
-                if (setBits - used <= pos) {
-                    count += slct[pos][setBits - used]
-                }
-                used++
-                if (used > setBits) {
-                    break
+    fun popcountDepth(n: Long, k: Int): Long {
+        if (k == 0) { return 1L }
+        fun countPop(x: Long, c: Int): Long {
+            var res = 0L
+            var ones = 0
+            var bits = 0
+            var t = x
+            while (t > 0) {
+                bits++
+                t = t shr 1
+            }
+            for (i in bits - 1 downTo 0) {
+                if ((x shr i) and 1L == 1L) {
+                    val rem = c - ones
+                    if (rem in 0..i) {
+                        res += comb[i][rem]
+                    }
+                    ones++
                 }
             }
+            return if (ones == c) res + 1 else res
         }
-        if (java.lang.Long.bitCount(upperLimit) == setBits) {
-            count++
-        }
-        return count
-    }
-
-    fun popcountDepth(tillNumber: Long, depthQuery: Int): Long {
-        if (depthQuery == 0) {
-            return (if (tillNumber >= 1) 1 else 0).toLong()
-        }
-        var total: Long = 0
-        for (ones in 1..<MX_LN) {
-            if (popHeight[ones] == depthQuery - 1) {
-                total += countNumbers(tillNumber, ones)
+        var ans = 0L
+        for (c in 1..60) {
+            if (depth[c] == k - 1) {
+                ans += countPop(n, c)
             }
         }
-        if (depthQuery == 1) {
-            total -= 1
-        }
-        return total
-    }
-
-    companion object {
-        private const val MX_LN = 61
+        if (k == 1) { ans-- }
+        return ans
     }
 }

src/main/kotlin/g3601_3700/s3622_check_divisibility_by_digit_sum_and_product/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3622_check_divisibility_by_digit_sum_and_product
 
-// #Easy #2025_07_20_Time_0_ms_(100.00%)_Space_40.53_MB_(_%)
+// #Easy #Weekly_Contest_459 #2025_07_22_Time_0_ms_(100.00%)_Space_40.35_MB_(100.00%)
 
 class Solution {
     fun checkDivisibility(n: Int): Boolean {

src/main/kotlin/g3601_3700/s3623_count_number_of_trapezoids_i/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3623_count_number_of_trapezoids_i
 
-// #Medium #2025_07_20_Time_30_ms_(99.91%)_Space_100.40_MB_(100.00%)
+// #Medium #Weekly_Contest_459 #2025_07_22_Time_58_ms_(68.00%)_Space_139.38_MB_(8.00%)
 
 class Solution {
     fun countTrapezoids(points: Array<IntArray>): Int {

src/main/kotlin/g3601_3700/s3624_number_of_integers_with_popcount_depth_equal_to_k_ii/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3624_number_of_integers_with_popcount_depth_equal_to_k_ii
 
-// #Hard #2025_07_20_Time_27_ms_(96.92%)_Space_125.98_MB_(100.00%)
+// #Hard #Weekly_Contest_459 #2025_07_22_Time_38_ms_(100.00%)_Space_134.15_MB_(100.00%)
 
 class Solution {
     private fun computeDepth(number: Long): Int {

src/main/kotlin/g3601_3700/s3625_count_number_of_trapezoids_ii/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3625_count_number_of_trapezoids_ii
 
-// #Hard #2025_07_21_Time_354_ms_(100.00%)_Space_131.52_MB_(52.31%)
+// #Hard #Weekly_Contest_459 #2025_07_22_Time_377_ms_(100.00%)_Space_162.04_MB_(37.50%)
 
 import kotlin.math.abs