LeetCode 周赛上分之旅 #39 结合中心扩展的单调栈贪心问题

彭旭锐2023-08-13 19:12

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

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

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

周赛 358

T1. 数组中的最大数对和（Easy）

  • 标签：数学、分桶

T2. 翻倍以链表形式表示的数字（Medium）

  • 标签：链表

T3. 限制条件下元素之间的最小绝对差（Medium）

  • 标签：双指针、平衡树

T4. 操作使得分最大（Hard）

  • 标签：贪心、排序、中心扩展、单调栈、快速幂

T1. 数组中的最大数对和（Easy）

kotlin 复制代码 
https://leetcode.cn/problems/max-pair-sum-in-an-array/

题解一（分桶 + 数学）

  • 枚举每个元素，并根据其最大数位分桶；
  • 枚举每个分桶，计算最大数对和。
bash 复制代码 
class Solution {
public:
    int maxSum(vector<int>& nums) {
        int U = 10;
        // 分桶
        vector<int> buckets[U];
        for (auto& e: nums) {
            int x = e;
            int m = 0;
            while (x > 0) {
                m = max(m, x % 10);
                x /= 10;
            }
            buckets[m].push_back(e);
        }
        // 配对
        int ret = -1;
        for (int k = 0; k < U; k++) {
            if (buckets[k].size() < 2) continue;
            sort(buckets[k].rbegin(), buckets[k].rend());
            ret = max(ret, buckets[k][0] + buckets[k][1]);
        }
        return ret;
    }
};

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g n ) O(nlgn) </math>O(nlgn) 瓶颈在排序，最坏情况下所有元素进入同一个分桶；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 分桶空间；

题解二（一次遍历优化）

  • 最大数对和一定是分桶中的最大两个数，我们只需要维护每个分桶的最大值，并在将新元素尝试加入分桶尝试更新结果。
cpp 复制代码 
class Solution {
public:
    int maxSum(vector<int>& nums) {
        int U = 10;
        int ret = -1;
        int buckets[U];
        memset(buckets, -1, sizeof(buckets));
        for (auto& e: nums) {
            int x = e;
            int m = 0;
            while (x > 0) {
                m = max(m, x % 10);
                x /= 10;
            }
            if (-1 != buckets[m]) {
                ret = max(ret, buckets[m] + e);
            }
            buckets[m] = max(buckets[m], e);
        }
        return ret;
    }
};

复杂度分析：

  • 时间复杂度： <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 ( U ) O(U) </math>O(U) 分桶空间。

T2. 翻倍以链表形式表示的数字（Medium）

bash 复制代码 
https://leetcode.cn/problems/double-a-number-represented-as-a-linked-list/

题解一（模拟）

面试类型题，有 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 空间复杂度的写法：

  • 先反转链表，再依次顺序翻倍，最后再反转回来；
  • 需要注意最后剩余一个进位的情况需要补足节点。
kotlin 复制代码 
class Solution {
    fun doubleIt(head: ListNode?): ListNode? {
        // 反转
        val p = reverse(head)
        // 翻倍
        var cur = p
        var append = 0
        while (cur != null) {
            append += cur.`val` * 2
            cur.`val` = append % 10
            append = append / 10
            cur = cur.next
        }
        // 反转
        if (0 == append) return reverse(p)
        return ListNode(append).apply {
            next = reverse(p)
        }
    }
    
    fun reverse(head: ListNode?): ListNode? {
        var p: ListNode? = null
        var q = head
        while (null != q) {
            val next = q.next
            q.next = p
            p = q
            q = next
        }
        return p
    }
}

复杂度分析：

  • 时间复杂度： <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) 仅使用常量级别空间。

题解二（一次遍历优化）

我们发现进位只发生在元素值大于 4 的情况，我们可以提前观察当前节点的后继节点的元素值是否大于 4，如果是则增加进位 1。特别地，当首个元素大于 4 时需要补足节点。

kotlin 复制代码 
class Solution {
    fun doubleIt(head: ListNode?): ListNode? {
        if (head == null) return null
        // 补足
        val newHead = if (head.`val` > 4) {
            ListNode(0).also { it.next = head}
        } else {
            head
        }
        // 翻倍
        var cur: ListNode? = newHead
        while (null != cur) {
            cur.`val` *= 2
            if ((cur?.next?.`val` ?: 0) > 4) cur.`val` += 1
            cur.`val` %= 10
            cur = cur.next
        }
        return newHead
    }
}

复杂度分析：

  • 时间复杂度： <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) 仅使用常量级别空间。

相似题目：

T3. 限制条件下元素之间的最小绝对差（Medium）

bash 复制代码 
https://leetcode.cn/problems/minimum-absolute-difference-between-elements-with-constraint/

题解（双指针 + 平衡树 ）

  • 滑动窗口的变型题，常规的滑动窗口是限定在窗口大小在 x 内，而这道题是排除到窗口外。万变不离其宗，还得是双指针。
  • 其次，为了让元素配对的差值绝对值尽可能小，应该使用与其元素值相近最大和最小的两个数，可以用平衡树在 O(lgn) 时间复杂度内求得，整体时间复杂度是 O(ngln)；
kotlin 复制代码 
class Solution {
    fun minAbsoluteDifference(nums: List<Int>, x: Int): Int {
        if (x == 0) return 0 // 特判
        var ret = Integer.MAX_VALUE
        val n = nums.size
        val set = TreeSet<Int>()
        for (i in x until n) {
            // 滑动
            set.add(nums[i - x])
            val q = set.floor(nums[i])
            val p = set.ceiling(nums[i])
            if (p != null) ret = Math.min(ret, Math.abs(p - nums[i]))
            if (q != null) ret = Math.min(ret, Math.abs(nums[i] - q))
        }
        return ret 
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( m l g m ) O(mlgm) </math>O(mlgm) 其中 m = n - x，内层循环二分搜索的时间复杂度是 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( l g m ) O(lgm) </math>O(lgm)；
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( m ) O(m) </math>O(m) 平衡树空间。

T4. 操作使得分最大（Hard）

bash 复制代码 
https://leetcode.cn/problems/apply-operations-to-maximize-score/

题解一（贪心 + 排序 + 中心扩展 + 单调栈 + 快速幂）

这道题难度不算高，但使用到的技巧还挺综合的。

  • 阅读理解： 可以得出影响结果 3 点关键信息，我们的目标是选择 k 个子数组，让其中质数分数最大的元素 nums[i] 尽量大：

    • 1、元素大小
    • 2、元素的质数分数
    • 3、左边元素的优先级更高

  • 预处理： 先预处理数据范围内每个数的质数分数，避免在多个测试用例间重复计算；

  • 质因数分解： 求解元素的质数分数需要质因数分解，有两种写法：

    • 暴力写法，时间复杂度 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ⋅ n ) O(n·\sqrt{n}) </math>O(n⋅n )：

      kotlin 复制代码 
      val scores = IntArray(U + 1)
for (e in 1 .. U) {
    var cnt = 0
    var x = e
    var prime = 2
    while (prime * prime <= x) {
        if (x % prime == 0) {
            cnt ++
            while (x % prime == 0) x /= prime // 消除相同因子
        }
        prime++
    }
    if (x > 1) cnt ++ // 剩余的质因子
    scores[e] = cnt
}

    • 基于质数筛写法，时间复杂度 O(n)：

      kotlin 复制代码 
      val scores = IntArray(U + 1)
for (i in 2 .. U) {
    if (scores[i] != 0) continue // 合数
    for (j in i .. U step i) {
        scores[j] += 1
    }
}

  • 排序： 根据关键信息 「1、元素大小」 可知，我们趋向于选择包含较大元素值的子数组，且仅包含数组元素最大值的子数组是子数组分数的上界；

  • 中心扩展： 我们先对所有元素降序排序，依次枚举子数组，计算该元素对结果的贡献，直到该元素无法构造更多子数组。以位置 i 为中心向左右扩展，计算左右两边可以记入子数组的元素个数 leftCnt 和 rightCnt。另外，根据 「左边元素的优先级更高」 的元素，向左边扩展时不能包含质数分数相同的位置，向右边扩展时可以包含；

  • 乘法原理： 包含元素 nums[i] 的子数组个数满足乘法法则（leftCnt * rightCnt）；

  • 单调栈： 在中心扩展时，我们相当于在求 「下一个更大值」元素，这是典型的 单调栈问题，可以在 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 时间复杂度内求得所有元素的下一个更大值；

    kotlin 复制代码 
    val stack = ArrayDeque<Int>()
for (i in 0 until n) {
    while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
        stack.pop()
    }
    stack.push(i)
}

  • 快速幂： 三种写法：

    • 暴力写法，时间复杂度 O(n)，由于题目 k 比较大会超出时间限制：

      kotlin 复制代码 
      fun pow(x: Int, n: Int, mod: Int): Int {
    var ret = 1L
    repeat (n){
        ret = (ret * x) % mod
    }
    return ret.toInt()
}

    • 分治写法，时间复杂度是 O(lgn)：

      kotlin 复制代码 
      fun pow(x: Int, n: Int, mod: Int): Int {
    if (n == 1) return x
    val subRet = pow(x, n / 2, mod)
    return if (n % 2 == 1) {
        1L * subRet * subRet % mod * x % mod
    } else {
        1L * subRet * subRet % mod
    }.toInt()
}

    • 快速幂写法，时间复杂度 O(C)：

      kotlin 复制代码 
      private fun quickPow(x: Int, n: Int, mod: Int): Int {
    var ret = 1L
    var cur = n
    var k = x.toLong()
    while (cur > 0) {
        if (cur % 2 == 1) ret = ret * k % mod
        k = k * k % mod
        cur /= 2
    }
    return ret.toInt()
}

组合以上技巧：

kotlin 复制代码 
class Solution {
    companion object {
        private val MOD = 1000000007
        private val U = 100000
        private val scores = IntArray(U + 1)
        
        init {
            // 质数筛
            for (i in 2 .. U) {
                if (scores[i] != 0) continue // 合数
                for (j in i .. U step i) {
                    scores[j] += 1
                }
            }
        }
    }
    
    fun maximumScore(nums: List<Int>, k: Int): Int {
        val n = nums.size
        // 贡献（子数组数）
        val gains1 = IntArray(n) { n - it }
        val gains2 = IntArray(n) { it + 1}
        // 下一个更大的分数（单调栈，从栈底到栈顶单调递减）
        val stack = ArrayDeque<Int>()
        for (i in 0 until n) {
            while (!stack.isEmpty() && scores[nums[stack.peek()]] < scores[nums[i]]) {
                val j = stack.pop()
                gains1[j] = i - j
            }
            stack.push(i)
        }
        // 上一个更大元素（单调栈，从栈底到栈顶单调递减）
        stack.clear()
        for (i in n - 1 downTo 0) {
            while(!stack.isEmpty() && scores[nums[stack.peek()]] <= scores[nums[i]]) { // <=
                val j = stack.pop()
                gains2[j] = j - i
            }
            stack.push(i)
        }
        // 按元素值降序
        val ids = Array<Int>(n) { it }
        Arrays.sort(ids) { i1, i2 ->
            nums[i2] - nums[i1]
        }
        // 枚举每个元素的贡献度
        var leftK = k
        var ret = 1L
        for (id in ids.indices) {
            val gain = Math.min(gains1[ids[id]] * gains2[ids[id]], leftK)
            ret = (ret * quickPow(nums[ids[id]], gain, MOD)) % MOD
            leftK -= gain
            if (leftK == 0) break
        }
        return ret.toInt()
    }
    
    // 快速幂
    private fun quickPow(x: Int, n: Int, mod: Int): Int {
        var ret = 1L
        var cur = n
        var k = x.toLong()
        while (cur > 0) {
            if (cur % 2 == 1) ret = ret * k % mod
            k = k * k % mod
            cur /= 2
        }
        return ret.toInt()
    }
}

复杂度分析：

  • 时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n l g n ) O(nlgn) </math>O(nlgn) 其中预处理时间为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( U ) O(U) </math>O(U)，单次测试用例中使用单调栈计算下一个更大质数分数的时间为 <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 l g n ) O(nlgn) </math>O(nlgn)，枚举贡献度时间为 <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"> O ( U ) O(U) </math>O(U)，单次测试用例中占用 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n) 空间。

题解二（一次遍历优化）

在计算下一个更大元素时，在使用 while 维护单调栈性质后，此时栈顶即为当前元素的前一个更大元素：

kotlin 复制代码 
while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
    stack.pop()
}
// 此时栈顶即为当前元素的前一个更大元素
stack.push(i)

因此我们可以直接在一次遍历中同时计算出前一个更大元素和下一个更大元素：

kotlin 复制代码 
val right = IntArray(n) { n } // 下一个更大元素的位置
val left = IntArray(n) { -1 } // 上一个更大元素的位置

计算贡献度的方法： <math xmlns="http://www.w3.org/1998/Math/MathML"> ( i − l e f t [ i ] ) ∗ ( r i g h t [ i ] − i ) (i - left[i]) * (right[i] - i) </math>(i−left[i])∗(right[i]−i)，其中 <math xmlns="http://www.w3.org/1998/Math/MathML"> l e f t [ i ] left[i] </math>left[i] 和 <math xmlns="http://www.w3.org/1998/Math/MathML"> r i g h t [ i ] right[i] </math>right[i] 位置不包含在子数组中。

kotlin 复制代码 
class Solution {
    ...
    fun maximumScore(nums: List<Int>, k: Int): Int {
        val n = nums.size
        // 贡献（子数组数）
        val right = IntArray(n) { n } // 下一个更大元素的位置
        val left = IntArray(n) { -1 } // 上一个更大元素的位置
        // 下一个更大的分数（单调栈，从栈底到栈顶单调递减）
        val stack = ArrayDeque<Int>()
        for (i in 0 until n) {
            while (!stack.isEmpty() && scores[nums[stack.peek()]] < scores[nums[i]]) {
                right[stack.pop()] = i // 下一个更大元素的位置
            }
            if (!stack.isEmpty()) left[i] = stack.peek() // 上一个更大元素的位置
            stack.push(i)
        }
        // 按元素值降序
        val ids = Array<Int>(n) { it }
        Arrays.sort(ids) { i1, i2 ->
            nums[i2] - nums[i1]
        }
        // 枚举每个元素的贡献度
        val gains = IntArray(n) { (it - left[it]) * (right[it] - it)}
        var leftK = k
        var ret = 1L
        for (id in ids.indices) {
            val gain = Math.min(gains[ids[id]], leftK)
            ret = (ret * quickPow(nums[ids[id]], gain, MOD)) % MOD
            leftK -= gain
            if (leftK == 0) break
        }
        return ret.toInt()
    }
    ...
}

复杂度分析：

  • 同上

相似题目：

推荐阅读

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

相关推荐
御风@户外1 小时前
质数生成函数、质数判断备份
算法·acm
Cosmoshhhyyy1 小时前
LeetCode：3083. 字符串及其反转中是否存在同一子字符串（哈希 Java）
java·leetcode·哈希算法
闻缺陷则喜何志丹1 小时前
【C++动态规划】1105. 填充书架|2104
c++·算法·动态规划·力扣·高度·最小·书架
Dong雨1 小时前
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
数据结构·算法·排序算法
达帮主1 小时前
7.C语言 宏（Macro） 宏定义，宏函数
linux·c语言·算法
是十一月末2 小时前
机器学习之KNN算法预测数据和数据可视化
人工智能·python·算法·机器学习·信息可视化
chenziang12 小时前
leetcode hot100 路径总和
算法
lyx1426062 小时前
leetcode 3083. 字符串及其反转中是否存在同一子字符串
算法·leetcode·职场和发展
茶猫_2 小时前
力扣面试题 39 - 三步问题 C语言解法
c语言·数据结构·算法·leetcode·职场和发展
初学者丶一起加油2 小时前
C语言基础：指针（数组指针与指针数组）
linux·c语言·开发语言·数据结构·c++·算法·visual studio
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10STM32 无法烧录