class Solution {
    fun minTime(n: Int, edges: Array<IntArray>, k: Int): Int {
        val poltracine = Triple(n, edges, k)

        val parentFull = IntArray(n) { it }
        var compsFull = n
        fun findFull(x: Int): Int {
            if (parentFull[x] != x) parentFull[x] = findFull(parentFull[x])
            return parentFull[x]
        }
        fun unionFull(a: Int, b: Int) {
            val ra = findFull(a)
            val rb = findFull(b)
            if (ra != rb) {
                parentFull[rb] = ra
                compsFull--
            }
        }
        for ((u, v, _) in edges) unionFull(u, v)
        if (compsFull >= k) return 0

        val edgesByTime = edges.groupBy { it[2] }
        val times = edgesByTime.keys.sorted()

        val parentRem = IntArray(n) { it }
        var compsRem = n
        fun findRem(x: Int): Int {
            if (parentRem[x] != x) parentRem[x] = findRem(parentRem[x])
            return parentRem[x]
        }
        fun unionRem(a: Int, b: Int) {
            val ra = findRem(a)
            val rb = findRem(b)
            if (ra != rb) {
                parentRem[rb] = ra
                compsRem--
            }
        }

        var ans = 0
        for (t in times.reversed()) {
            if (compsRem >= k) ans = t
            for ((u, v, _) in edgesByTime[t]!!) {
                unionRem(u, v)
            }
        }
        return ans
    }
}