第 269 场周赛题解

Q1 2089. 找出数组排序后的目标下标 (opens new window)

签到。

class Solution2089 {
    fun targetIndices(nums: IntArray, target: Int): List<Int> {
        val ans = ArrayList<Int>()
        nums.sorted().forEachIndexed { index, i ->
            if (i == target) {
                ans.add(index)
            }
        }
        return ans
    }
}

Q2 2090. 半径为 k 的子数组平均值 (opens new window)

再次被Int坑，以后能用Long就用Long。

class Solution2090 {
    fun getAverages(nums: IntArray, k: Int): IntArray {
        var cur = 0L
        var size = 0
        val ans = IntArray(nums.size) { -1 }
        for (i in nums.indices) {
            cur += nums[i]
            size++
            if (size == k * 2 + 1) {
                ans[i - k] = (cur / size).toInt()
                cur -= nums[i - k * 2]
                size--
            }
        }
        return ans
    }
}

Q3 2091. 从数组中移除最大值和最小值 (opens new window)

获取最左侧和最右侧的坐标，直接从0删到到右侧，or 从n-1删到左侧，或删除两边，取其中最小值即可。

PS：力扣这Kotlin升级喊了一年了，一直不作为...

class Solution2091 {
    fun minimumDeletions(nums: IntArray): Int {
        val n = nums.size
//        val minIndex = nums.indexOf(nums.min()!!)
        val minIndex = nums.indexOf(nums.minOrNull()!!)
//        val maxIndex = nums.indexOf(nums.max()!!)
        val maxIndex = nums.indexOf(nums.maxOrNull()!!)
        val l = minOf(minIndex, maxIndex)
        val r = maxOf(minIndex, maxIndex)
        println("$l $r")
        return minOf(r + 1, n - l, l + 1 + n - r)
    }
}

Q4 2092. 找出知晓秘密的所有专家 (opens new window)

普通的BFS，每期队列初始值是当前时间点会议所有参加会议中已知晓秘密的人。

class SolutionD {
    fun findAllPeople(n: Int, meetings: Array<IntArray>, firstPerson: Int): List<Int> {
        val state = IntArray(n)
        state[0] = 1
        state[firstPerson] = 1
        meetings.sortBy { it[2] }
        var i = 0
        var cur = -1
        val l = ArrayList<IntArray>()

        fun check() {
            val map = HashMap<Int, ArrayList<Int>>()
            l.forEach {
                map[it[0]] = map.getOrDefault(it[0], arrayListOf())
                map[it[1]] = map.getOrDefault(it[1], arrayListOf())
                map[it[0]]!!.add(it[1])
                map[it[1]]!!.add(it[0])
            }
            val q: Queue<Int> = LinkedList<Int>()
            for (j in map.keys) {
                if (state[j] == 1)
                    q.offer(j)
            }
            while (q.isNotEmpty()) {
                val size = q.size
                for (i in 0 until size) {
                    val item = q.poll()
                    map[item]?.forEach {
                        if (state[it] == 0) {
                            state[it] = 1
                            q.offer(it)
                        }
                    }
                }
            }
            l.clear()
        }
        while (i in meetings.indices) {
            if (meetings[i][2] > cur) {
                cur = meetings[i][2]
                check()
                l.add(intArrayOf(meetings[i][0], meetings[i][1]))
            } else {
                l.add(intArrayOf(meetings[i][0], meetings[i][1]))
            }
            i++
        }
        check()

        val ans = ArrayList<Int>()
        for (i in state.indices) {
            if (state[i] == 1) {
                ans.add(i)
            }
        }
        return ans
    }
}