LeetCode 周赛上分之旅 #42 当 LeetCode 考树上倍增，出题的趋势在变化吗

彭旭锐2023-08-28 3:09

⭐️ 本文已收录到 AndroidFamily，技术和职场问题，请关注公众号 [彭旭锐] 和 BaguTree Pro 知识星球提问。

学习数据结构与算法的关键在于掌握问题背后的算法思维框架，你的思考越抽象，它能覆盖的问题域就越广，理解难度也更复杂。在这个专栏里，小彭与你分享每场 LeetCode 周赛的解题报告，一起体会上分之旅。

本文是 LeetCode 上分之旅系列的第 42 篇文章，往期回顾请移步到文章末尾~

周赛 360

T1. 距离原点最远的点（Easy）

  • 标签：模拟

T2. 找出美丽数组的最小和（Medium）

  • 标签：散列表、贪心、数学

T3. 使子序列的和等于目标的最少操作次数（Hard）

  • 标签：位运算、散列表、排序

T4. 在传球游戏中最大化函数值（Hard）

  • 标签：树、倍增、动态规划、内向基环树

T1. 距离原点最远的点（Easy）

bash 复制代码 
https://leetcode.cn/problems/furthest-point-from-origin/

题解（模拟）

根据题意 "" 既可以作为 "L" 也可以作为 "R"。容易想到，为了使得终点距离原点更远，当所有 "" 仅作为 "L" 或 "R" 对结果的贡献是最优的，此时问题的结果就取决于 "L" 和 "R" 的差绝对值。

kotlin 复制代码 
class Solution {
    fun furthestDistanceFromOrigin(moves: String): Int {
        return moves.count{ it == '_' } + abs(moves.count{ it == 'L' } - moves.count{ it == 'R' })
    }
}

一次遍历：

kotlin 复制代码 
class Solution {
    fun furthestDistanceFromOrigin(moves: String): Int {
        var cntL = 0
        var cntR = 0
        for (e in moves) {
            when (e) {
                'L' -> {
                    cntL ++
                    cntR --
                }
                'R' -> {
                    cntL --
                    cntR ++
                }
                else -> {
                    cntL ++
                    cntR ++
                }
            }
        }
        return max(abs(cntL), abs(cntR))
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 线性遍历；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 仅使用常量级别空间。

T2. 找出美丽数组的最小和（Medium）

bash 复制代码 
https://leetcode.cn/problems/find-the-minimum-possible-sum-of-a-beautiful-array/

这道题与上周周赛 359 T2 2829. k-avoiding 数组的最小总和 相比，除了数据范围之外是完全相同的，有点离谱。

题解一（散列表 + 贪心）

从 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1 开始从小到大枚举，如果当前元素 <math xmlns="http://www.w3.org/1998/Math/MathML"> c u r cur </math>cur 与已选列表不冲突，则加入结果中。为了验证是否冲突，我们使用散列表在 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 时间复杂度判断。

kotlin 复制代码 
class Solution {
    fun minimumPossibleSum(n: Int, k: Int): Long {
        val set = HashSet<Int>()
        var sum = 0L
        var cur = 1
        repeat(n) {
            while (!set.isEmpty() && set.contains(k - cur)) cur++
            sum += cur
            set.add(cur)
            cur++
        }
        return sum
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 线性遍历；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 散列表空间。

题解二（数学）

这道题还可以继续挖掘数学规律，我们发现当我们从 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1 开始从小到大枚举时，每选择一个数的同时必然会使得另一个数 <math xmlns="http://www.w3.org/1998/Math/MathML"> k − x k - x </math>k−x 不可选。例如：

  • 选择 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1，则 <math xmlns="http://www.w3.org/1998/Math/MathML"> k − 1 k - 1 </math>k−1 不可选；
  • 选择 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 2 </math>2，则 <math xmlns="http://www.w3.org/1998/Math/MathML"> k − 2 k - 2 </math>k−2 不可选；
  • ...
  • 选择 <math xmlns="http://www.w3.org/1998/Math/MathML"> k / 2 k / 2 </math>k/2，则 <math xmlns="http://www.w3.org/1998/Math/MathML"> k − k / 2 k - k / 2 </math>k−k/2 不可选。

可以发现，最终选择的元素被分为两部分：

  • 小于 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 的部分：选择所有和为 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 的配对中的较小值，即 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 、 2 、 3 ... k / 2 1、2、3 ... k / 2 </math>1、2、3...k/2；
  • 大于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 的部分：与其他任意正整数相加都不会等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k，因此大于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 的数必然可以选择，即 <math xmlns="http://www.w3.org/1998/Math/MathML"> k 、 k + 1 、 k + 2 、 ... 、 k + n − m − 1 k、k + 1、k + 2、...、k + n - m - 1 </math>k、k+1、k+2、...、k+n−m−1 共 n - m 个数。

我们令 <math xmlns="http://www.w3.org/1998/Math/MathML"> m = m i n ( k / 2 , n ) m = min(k / 2, n) </math>m=min(k/2,n)，使用求和公式可以 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 求出两部分的总和：

  • 小于 k 的部分： <math xmlns="http://www.w3.org/1998/Math/MathML"> m ( m + 1 ) / 2 m(m + 1)/ 2 </math>m(m+1)/2
  • 大于等于 k 的部分： <math xmlns="http://www.w3.org/1998/Math/MathML"> ( n − m ) ∗ ( 2 ∗ k + n − m − 1 ) / 2 (n - m) * (2*k + n - m - 1) / 2 </math>(n−m)∗(2∗k+n−m−1)/2
kotlin 复制代码 
class Solution {
    fun minimumPossibleSum(n: Int, k: Int): Long {
        val m = 1L * Math.min(n, k / 2)
        return m * (m + 1) / 2 + (n - m) * (2 * k + n - m - 1) / 2
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1)
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1)

T3. 使子序列的和等于目标的最少操作次数（Hard）

bash 复制代码 
https://leetcode.cn/problems/minimum-operations-to-form-subsequence-with-target-sum/

这道题的考点不复杂，难点在模拟问题挺考验编码功底的。

问题分析

  • 关键信息： <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组中所有元素都是 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 2 </math>2 的幂，元素顺序对结果没有影响；
  • 问题是否有解： 考虑到所有数最终都能拆分成 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1，那么只要 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组的和大于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target 就一定有解；
bash 复制代码 
# 二进制位
nums:   _ _ _ 1 _ _ _ _
target: _ _ _ _ _ 1 _ _
  • 子问题： 问题是否有解的判断不仅适用于原问题，对于仅考虑二进制位最低位 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ 0 ] [0] </math>[0] 到 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ k ] [k] </math>[k] 的子问题亦是如此。

以示例 1 nums = [1,2,8], target = 7 与示例 2 nums = [1,32,1,2], target = 12 为例，我们将统计 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 中不同 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 2 </math>2 的幂的出现次数：

bash 复制代码 
# 二进制位
nums:   _ _ _ _ 1 _ 1 1
target: _ _ _ _ _ 1 1 1

# 二进制位
nums:   _ _ 1 _ _ _ 1 2 # 1 出现 2 次
target: _ _ _ _ 1 1 _ _

那么当我们从右向左枚举二进制位 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 时，如果「 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 中小于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 k 2^k </math>2k 的元素和」 <math xmlns="http://www.w3.org/1998/Math/MathML"> ≥ ≥ </math>≥ 「 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target 中低于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 位的值」，那么对于仅考虑 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ 0 , k ] [0, k] </math>[0,k] 位上的子问题是有解的。否则，我们需要找到 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 中最近大于 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 k 2^k </math>2k 的最近数组做拆分：

bash 复制代码 
# 只考虑低 2 位，可以构造
nums:   _ _ _ _ 1 _ | 1 1
target: _ _ _ _ _ 1 | 1 1

# 只考虑低 3 位，无法构造，需要找到最近的 "1" 做拆分
nums:   _ _ _ _ 1 | _ 1 1
target: _ _ _ _ _ | 1 1 1

# 只考虑低 3 位，无法构造，需要找到最近的 "1" 做拆分
nums:   _ _ 1 _ _ | _ 1 2
target: _ _ _ _ 1 | 1 _ _

# 只考虑低 6 位，可以构造
nums:   _ _ | 1 _ _ _ 1 2
target: _ _ | _ _ 1 1 _ _

组合以上技巧：

写法一（数组模拟）

思路参考灵神的题解。

  • 首先，我们使用长为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 32 32 </math>32 的数组，计算出 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组中每个 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 2 </math>2 的幂的出现次数；
  • 随后，我们从低位到高位枚举二进制位 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i，在每轮迭代中将 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组中的 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 i 2^i </math>2i 元素累加到 <math xmlns="http://www.w3.org/1998/Math/MathML"> s u m sum </math>sum 中，此举相当于在求「低 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i 位的子问题」可以构造的最大值；
  • 最后，我们比较 <math xmlns="http://www.w3.org/1998/Math/MathML"> s u m sum </math>sum 是否大于等于 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target（只考虑低 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i 位），此举相当于在判断「低 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i 位的子问题」是否可构造。如果不可构造，我们尝试寻找最近的 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 j 2^j </math>2j 做拆分；
  • 另外，有一个优化点：当我们拆分将 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 j 2^j </math>2j 拆分到 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 i ( j > i ) 2^i (j > i) </math>2i(j>i) 时并不是直接丢弃 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 j 2^j </math>2j，而是会留下 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 j − 1 、 2 j − 2 ... 2 i 2^{j-1}、2^{j-2}... 2^i </math>2j−1、2j−2...2i 等一系列数，可以直接跳到第 <math xmlns="http://www.w3.org/1998/Math/MathML"> j j </math>j 位继续枚举。

注意一个容易 WA 的地方，在开头特判的地方，由于元素和可能会溢出 <math xmlns="http://www.w3.org/1998/Math/MathML"> I n t Int </math>Int 上界，所以我们需要转换为在 <math xmlns="http://www.w3.org/1998/Math/MathML"> L o n g Long </math>Long 上的求和。

kotlin 复制代码 
class Solution {
    fun minOperations(nums: List<Int>, target: Int): Int {
        if (nums.fold(0L) { it, acc -> it + acc } < target) return -1
        // if (nums.sum() < target) return -1 // 溢出
        // 计数
        val cnts = IntArray(32)
        for (num in nums) {
            var i = 0
            var x = num
            while (x > 1) {
                x = x shr 1
                i += 1
            }
            cnts[i]++
        }
        var ret = 0
        var i = 0
        var sum = 0L
        while(sum < target) {
            // 累加低位的 nums
            sum += (cnts[i]) shl i
            // println("i=$i, sum=$sum")
            // 低 i 位掩码
            val mask = (1 shl (i + 1)) - 1
            // 构造子问题
            if (sum < target and mask) {
                var j = i + 1
                while (cnts[j] == 0) { // 基于开头的特判，此处一定有解
                    j++
                }
                // 拆分
                ret += j - i
                i = j
            } else {
                i += 1
            }
        }
        return ret
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ⋅ U + U O(n·U + U </math>O(n⋅U+U) 其中 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 为 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组的长度， <math xmlns="http://www.w3.org/1998/Math/MathML"> U U </math>U 为整型大小 <math xmlns="http://www.w3.org/1998/Math/MathML"> 32 32 </math>32；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( U ) O(U) </math>O(U) 数组空间。

写法二（散列表模拟）

在计数的部分，我们可以使用散列表模拟，复杂度相同。

kotlin 复制代码 
class Solution {
    fun minOperations(nums: List<Int>, target: Int): Int {
        if (nums.fold(0L) { it, acc -> it + acc } < target) return -1
        // if (nums.sum() < target) return -1 // 溢出
        // 计数
        val cnts = HashMap<Int, Int>()
        for (num in nums) {
            cnts[num] = cnts.getOrDefault(num, 0) + 1
        }
        var ret = 0
        var i = 0
        var sum = 0L
        while(sum < target) {
            // 累加低位的 nums
            sum += (cnts[1 shl i] ?: 0) shl i
            // println("i=$i, sum=$sum")
            // 低 i 位掩码
            val mask = (1 shl (i + 1)) - 1
            // 构造子问题
            if (sum < target and mask) {
                var j = i + 1
                while (!cnts.containsKey(1 shl j)) { // 基于开头的特判，此处一定有解
                    j++
                }
                // 拆分
                ret += j - i
                i = j
            } else {
                i += 1
            }
        }
        return ret
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n + U ) O(n + U) </math>O(n+U) 其中 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 为 <math xmlns="http://www.w3.org/1998/Math/MathML"> n u m s nums </math>nums 数组的长度， <math xmlns="http://www.w3.org/1998/Math/MathML"> U U </math>U 为整型大小 <math xmlns="http://www.w3.org/1998/Math/MathML"> 32 32 </math>32；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( U ) O(U) </math>O(U) 散列表空间。

写法三（逆向思维）

思路参考雪景式的题解，前两种写法是在从小到大枚举「选哪个」，我们也可以枚举「不选哪个」。

  • 思考 1： 在原问题有解 <math xmlns="http://www.w3.org/1998/Math/MathML"> （ s u m > t a r g e t ） （sum > target） </math>（sum>target）的情况下，如果从 <math xmlns="http://www.w3.org/1998/Math/MathML"> s u m sum </math>sum 中剔除最大的元素 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 后，依然满足剩余的元素和 <math xmlns="http://www.w3.org/1998/Math/MathML"> s u m ' > t a r g e t sum' > target </math>sum'>target，那么直接将 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 去掉，这是因为一定存在比 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 操作次数更小的方案能够构造 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target（元素越大拆分次数越多）。
  • 思考 2： 如果从 <math xmlns="http://www.w3.org/1998/Math/MathML"> s u m sum </math>sum 中剔除最大的元素 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 后不能构造，说明 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 是一定要选择或者拆分，此时考虑 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 对 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target 的影响：
    • 如果 <math xmlns="http://www.w3.org/1998/Math/MathML"> x > t a r g e t x > target </math>x>target，那么 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 需要先拆分
    • 如果 <math xmlns="http://www.w3.org/1998/Math/MathML"> x ≤ t a r g e t x ≤ target </math>x≤target，那么 <math xmlns="http://www.w3.org/1998/Math/MathML"> x x </math>x 可以被选择并抵消 <math xmlns="http://www.w3.org/1998/Math/MathML"> t a r g e t target </math>target
kotlin 复制代码 
class Solution {
    fun minOperations(nums: MutableList<Int>, target: Int): Int {
        var sum = nums.fold(0L) { it, acc -> it + acc }
        if (sum < target) return -1
        // 排序
        nums.sortDescending()
        // 从大到小枚举
        var ret = 0
        var left = target
        while (sum > left) {
            val x = nums.removeFirst()
            if (sum - x >= left){
                sum -= x
            } else if (x <= left) {
                sum -= x
                left -= x
            } else {
                ret += 1
                nums.add(0, x / 2)
                nums.add(0, x / 2)
            }
            // println("ret=$ret, sum=$sum, left=$left, x=$x,  nums=${nums.joinToString()}")
        }
        return ret
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g n + n + U ) O(nlgn + n + U) </math>O(nlgn+n+U) 瓶颈在排序，枚举阶段每个元素最多访问 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1 次，拆分次数最多为 <math xmlns="http://www.w3.org/1998/Math/MathML"> U U </math>U；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( l g n ) O(lgn) </math>O(lgn) 排序递归栈空间。

T4. 在传球游戏中最大化函数值（Hard）

bash 复制代码 
https://leetcode.cn/problems/maximize-value-of-function-in-a-ball-passing-game/

题解（树上倍增）

从近期周赛的趋势看，出题人似乎有意想把 LeetCode 往偏竞赛的题目引导。

这道题如果知道树上倍增算法，其实比第三题还简单一些。

  • 问题目标： 找到最佳方案，使得从起点开始传球 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 次的路径和最大化；
  • 暴力： 对于暴力的做法，我们可以枚举以每名玩家为起点的方案，并模拟传球过程求出最佳方案。但是这道题的步长 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 的上界非常大 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 0 10 10^{10} </math>1010，如果逐级向上传球，那么单次查询的时间复杂度是 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( k ) O(k) </math>O(k)。现在，需要思考如何优化模拟 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 次传球的效率；
  • 倍增思想： 借鉴 1483. 树节点的第 K 个祖先 的解法，我们可以利用倍增算法将线性的操作施加指数级别的贡献：
    • 如果可以预处理出每个玩家的多级后驱玩家，那么在查询时可以加速跳转；
    • 由于每个数都可以进行二进制拆分为多个 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 2 </math>2 的幂的和，如果预处理出第 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 0 、 2 1 、 2 2 、 2 3 、 . . . 、 2 i 2^0、2^1、2^2、2^3、...、2^i </math>20、21、22、23、...、2i 个后驱玩家，那么求解第 <math xmlns="http://www.w3.org/1998/Math/MathML"> k k </math>k 次传球时可以转化为多次 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 i 2^i </math>2i 个后驱玩家跳转操作，大幅减少操作次数。
kotlin 复制代码 
class Solution {
    fun getMaxFunctionValue(receiver: List<Int>, k: Long): Long {
        val n = receiver.size
        val m = 64 - k.countLeadingZeroBits()
        // 预处理
        // dp[i][j] 表示 i 传球 2^j 次后的节点
        val dp = Array(n) { IntArray(m) }
        // dp[i][j] 表示 i 传球 2^j 次的路径和
        val sum = Array(n) { LongArray(m) }
        for (i in 0 until n) {
            dp[i][0] = receiver[i]
            sum[i][0] = receiver[i].toLong()
        }
        for (j in 1 until m) {
            for (i in 0 until n) { // 这道题没有根节点，不需要考虑 child == -1 的情况
                val child = dp[i][j - 1]
                // 从 i 条 2^{j-1} 次，再跳 2^{j-1}
                dp[i][j] = dp[child][j - 1]
                sum[i][j] = sum[i][j - 1] + sum[child][j - 1]
            }
        }
        // 枚举方案
        var ret = 0L
        for (node in 0 until n) {
            var i = node
            var x = k
            var s = node.toLong() // 起点的贡献
            while (x != 0L) {
                val j = x.countTrailingZeroBits()
                s += sum[i][j]
                i = dp[i][j]
                x = x and (x - 1)
            }
            ret = max(ret, s)
        }
        return ret
    }
}

复杂度分析：

  • 时间复杂度：预处理时间为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g k ) O(nlgk) </math>O(nlgk)，枚举时间为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g k ) O(nlgk) </math>O(nlgk)，其中 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 为 <math xmlns="http://www.w3.org/1998/Math/MathML"> r e c e i v e r s receivers </math>receivers 数组的长度；
  • 空间复杂度：预处理空间 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g k ) O(nlgk) </math>O(nlgk)。

另外，这道题还有基于「内向基环树」的 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 解法。

推荐阅读

LeetCode 上分之旅系列往期回顾：

相关推荐
keep intensify1 小时前
数据结构---单链表的增删查改
c语言·数据结构·c++·经验分享·学习·算法·分享
opple661 小时前
力扣-数据结构-二叉树
数据结构·算法·leetcode
import_random1 小时前
[社交网络]布局算法(可视化)
算法
时光话2 小时前
Lua 第14部分 数据结构
开发语言·数据结构·lua
地平线开发者2 小时前
C++ 部署的性能优化方法
c++·算法·自动驾驶
怀念无所不能的你2 小时前
acwing背包问题求方案数
学习·算法·动态规划·dp
Yingye Zhu(HPXXZYY)2 小时前
洛谷P12238 [蓝桥杯 2023 国 Java A] 单词分类
c++·算法·蓝桥杯
Phoebe鑫2 小时前
数据结构每日一题day13（链表）★★★★★
数据结构·链表
Seven973 小时前
缓存穿透的解决方式？—布隆过滤器
java·数据结构·redis
积极向上的向日葵3 小时前
链表的中间节点
数据结构·算法·链表·快慢指针
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03西电B测-计算机网络综合实验(含验收问题)04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【VIsion Master】机器视觉软件二次开发（C#版本）学习笔记08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09我决定放弃搞 Java 了10Python基于Flask的豆瓣电影数据分析可视化系统（附源码，文档说明）