LeetCode 双周赛 98，脑筋急转弯转不过来！

大家好，我是小彭。

昨晚是 LeetCode 第 98 场双周赛，你参加了吗？这场周赛需要脑筋急转弯，转不过来 Medium 就会变成 Hard，转得过来就变成 Easy。

2566. 替换一个数字后的最大差值（Easy）

题目地址

https://leetcode.cn/problems/maximum-difference-by-remapping-a-digit/

题目描述

给你一个整数 num 。你知道 Danny Mittal 会偷偷将 0 到 9 中的一个数字替换成另一个数字。

请你返回将 num 中 恰好一个 数字进行替换后，得到的最大值和最小值的差位多少。

注意：

当 Danny 将一个数字 d1 替换成另一个数字 d2 时，Danny 需要将 nums 中所有 d1 都替换成 d2 。
Danny 可以将一个数字替换成它自己，也就是说 num 可以不变。
Danny 可以将数字分别替换成两个不同的数字分别得到最大值和最小值。
替换后得到的数字可以包含前导 0 。
Danny Mittal 获得周赛 326 前 10 名，让我们恭喜他。

题解（字符串操作）

技巧：将整型转换为字符串能够更方便地修改具体位置。

简单模拟题，有 2 个思路：

思路 1 - 暴力枚举：尝试枚举每类的数字，将其替换为 9 取得最大值，将其替换为 0 取得最小值，最后取所有方案的最大值和最小值取差值；
思路 2 - 贪心思路：替换越靠近 “高位” 的数字能够使得差值越大，所以我们将从高位开始的首个非 9 数字替换为 9（例如 90 替换为 99）必然得到最大值，将从高位开始的首个数字替换为 0（例如 90 替换为 00）必然得到最小值。

// 思路 1
class Solution {
    fun minMaxDifference(num: Int): Int {
        val numStr = "$num"
        var max = num
        var min = num
        for (element in numStr) {
            max = Math.max(max, numStr.replace(element, '9').toInt())
            min = Math.min(min, numStr.replace(element, '0').toInt())
        }
        return max - min
    }
}

复杂度分析：

时间复杂度： $O(log^2\,{num})$ 数字最多有 log num 位，外层循环与内存循环的字符串替换操作都是 $O(log\,{num})$ 时间级别复杂度；
空间复杂度： $O(log\,{num})$ 字符串占用空间。

// 思路 2
class Solution {
    fun minMaxDifference(num: Int): Int {
        val numStr = "$num"
        val min = numStr.replace(numStr[0], '0').toInt()
        var max = num
        for (element in numStr) {
            if ('9' != element) {
                max = numStr.replace(element, '9').toInt()
                break
            }
        }
        return max - min
    }
}

复杂度分析：

时间复杂度： $O(log\,{num})$ 内存循环的字符串替换操作最多只会执行一次，均摊下来整体只有 $O(log\,{num})$ 级别的时间复杂度；
空间复杂度： $O(log\,{num})$ 字符串占用空间。

2567. 修改两个元素的最小分数（Medium)

题目地址

https://leetcode.cn/problems/minimum-score-by-changing-two-elements/

题目描述

给你一个下标从 0 开始的整数数组 nums 。

nums 的最小得分是满足 0 <= i < j < nums.length 的 |nums[i] - nums[j]| 的最小值。
nums的最大得分是满足 0 <= i < j < nums.length 的 |nums[i] - nums[j]| 的最大值。
nums 的分数是最大得分与最小得分的和。

我们的目标是最小化 nums 的分数。你最多可以修改 nums 中 2 个元素的值。

请你返回修改 nums 中 至多两个 元素的值后，可以得到的 最小分数 。

|x| 表示 x 的绝对值。

题解（排序 + 枚举）

这道题也有脑筋急转弯的成分，同时我们可以扩展思考下 “最多修改 k 个元素的最小得分” 问题，最后再说。

这道题的关键在于得分的定义：

“最小得分” 表示任意数组中两个数字之间的最小绝对差；
“最大得分” 表示任意数组中两个数字之间的最大绝对差。

理解题意后容易发现：

影响 “最小得分” 的是数组中最接近的两个数字。当数组中存在两个相同元素时，“最小得分” 可以取到最小值 0；
影响 “最大得分” 的是数组中最不接近的两个数，即最大值和最小值。当我们将最大值和最小值修改为数组中间的某个元素时，能使得差值变小的同时，保持 “最小得分” 取最小值 0。

因此得知： 这道题的关键点在于修改数组的最大值或最小值成为数组中间的某个元素。 要么让最大值变小，要么让最小值变大。由于题目最多只能修改 2 次，因此最多只能以下 3 种情况：

情况 1：修改数组中最大的两个数为 nums[n - 3]；
情况 2：修改数组中最小的两个数为 nums[2]；
情况 3：修改数组的最大值为 nums[n - 1]，修改数组的最小值为 nums[1]。

简单枚举出 3 种情况的解后再进行一轮比较即可。

最后再观察边界条件，数组的最小长度为 3，所以不需要特判。

class Solution {
    fun minimizeSum(nums: IntArray): Int {
        nums.sort()
        val n = nums.size
        val choice1 = nums[n - 3] - nums[0]
        val choice2 = nums[n - 1] - nums[2]
        val choice3 = nums[n - 2] - nums[1]
        return Math.min(choice1, Math.min(choice2, choice3))
    }
}

复杂度分析：

时间复杂度： $O(nlgn)$ 快速排序占用的时间，如果手动维护最小的 3 个元素和最大的 3 个元素可以降低到 $O(n)$ 时间复杂度；
空间复杂度： $O(lgn)$ 排序占用的递归栈空间。

再扩展思考一下，如果题目说明最多可以修改 $k （0 ≤ k ≤ nums.length）$ 次的话，应该解决问题呢？ —— 即 “求最多修改 k 个元素的最小得分”，原题就是 k = 2 的情况。

那么这道题就是考察 “滑动窗口” 技巧了，我们可以将修改的范围视为一个跨越数组首尾且长度为 k 的滑动窗口，那么而问题的答案就取决于 “不被” 滑动窗口包围的另一部分。再逆向思考一下，我们可以用长度为 length - k 的滑动窗口在数组上移动，并记录窗口首尾元素的差值，枚举所有情况后记录最小值即为最小得分：

举个例子，在输入数组为 [1, 4, 5, 7, 8] ，k = 2 时，前文提到的 3 种方案分别对应以下 3 个窗口状态：

情况 1：修改数组中最大的两个数：1,4 | 5,7,8 |
情况 2：修改数组中最小的两个数：| 1,4,5 | 7,8
情况 3：修改数组的最大值和最小值：1 | 4,5,7 | 8

class Solution {
    fun minimizeSum(nums: IntArray): Int {
        val n = nums.size
        // 操作次数
        val k = 2
        // 滑动窗口
        val len = n - k
        nums.sort()
        var min = Integer.MAX_VALUE
        for (left in 0..n - len) {
            val right = left + len - 1
            min = Math.min(min, nums[right] - nums[left])
        }
        return min
    }
}

复杂度分析同上。

2568. 最小无法得到的或值（Medium）

题目地址

https://leetcode.cn/problems/minimum-impossible-or/

题目描述

给你一个下标从 0 开始的整数数组 nums 。

如果存在一些整数满足 0 <= index1 < index2 < ... < indexk < nums.length ，得到 nums[index1] | nums[index2] | ... | nums[indexk] = x ，那么我们说 x 是 可表达的 。换言之，如果一个整数能由 nums 的某个子序列的或运算得到，那么它就是可表达的。

请你返回 nums 不可表达的 最小非零整数 。

题解一（散列表）

相似题目：2154. 将找到的值乘以 2

这道题需要脑筋急转弯。

首先，我们先观察输入数据范围中小数值的二进制表示，尝试发现规律：

0 = 0000 = 0
1 = 0001 = 1
2 = 0010 = 2
3 = 0011 = 2 | 1
4 = 0100 = 4
5 = 0101 = 4 | 1
6 = 0110 = 4 | 2
7 = 0111 = 4 | 2 | 1，或者 5 | 1
8 = 1000 = 8
9 = 1001 = 8 | 1
10 = 1010 = 8 | 2

我们发现以下 2 点信息：

除了数字 7 = 5 | 1 的特殊方案外，其他数字的表示方案都可以由形如 $x = 2^i | 2^j | 2^ k$ 的格式表达（很容易理解）；
$2^i$ 格式的数字不可能被其他数用 “或” 的形式表示（也很容易理解）。

由此可以得出结论： 影响数组最小可表达数的关键在于数组中 “未出现的最小的 $2^i$ ”，并且这个数就是不可表达的最小非零数。

举例说明：假设 8 是数组中未出现的最小 $2^i$ （此时 [1, 2, 4] 肯定在数组中出现 $2^i$ ），那么数字 1 ~ 7 之间的所有数字都可以由 [1、2、4] 通过或表示，而 8 无法被 [1, 2, 3, 4, 5, 6 ,7] 之间的任何数字表达，同时也无法被大于 8 的其他数表示，因此 8 就是最小的可表达数。

完成问题转换后编码就很容易了，我们只要从小到大枚举所有 $2^i$ ，并检查它是否在数组中出现即可：

class Solution {
    fun minImpossibleOR(nums: IntArray): Int {
        val numSet = nums.toHashSet()
        var i = 1
        while (numSet.contains(i)) {
            i = i shl 1
        }
        return i
    }
}

复杂度分析：

时间复杂度： $O(n + logU)$ 其中 n 是数组长度，U 是数组的最大值，最多只需要检查 logU 位数字；
空间复杂度： $O(n)$ 散列表占用的空间。

题解二（位运算）

题解一使用散列表来辅助判断 $2^i$ 是否存在于数组中，可以进一步优化：我们将直接从数组元素的二进制数据中提取特征值，并还原出 “未出现的最小的 $2^i$ ”：

1、遍历数组中所有元素，如果元素值是 $2^i$ 则将其记录到 mask 特征值中；
2、遍历结束后将得到形如 0011, 1011 格式的特征值，此时 “未出现的最小的 $2^i$ ” 正好位于从低位到高位出现的首个 0 的位置，即 0000, 0100;
3、为了还原出目标数，执行以下位运算：

x = ~x // 按位取反：    0011,1011 => 1100,0100
x & -x // lowbit 公式：1100,0100 => 0000,0100

class Solution {
    fun minImpossibleOR(nums: IntArray): Int {
        var mask = 0
        for (x in nums) {
            // x & (x - 1) 将消除最低位的 1，如果消除后值为 1 说明 x 本身就是 2 的幂
            if (x and (x - 1) == 0) mask = mask or x
        }
        // 取反
        mask = mask.inv()
        // 取最低位 1 
        return mask and -mask
    }
}

复杂度分析：

时间复杂度： $O(n)$ 其中 n 是数组长度；
空间复杂度： $O(1)$ 仅占用常数级别空间。

2569. 更新数组后处理求和查询（Hard）

题目地址

https://leetcode.cn/problems/handling-sum-queries-after-update/

题目描述

给你两个下标从 0 开始的数组 nums1 和 nums2 ，和一个二维数组 queries 表示一些操作。总共有 3 种类型的操作：

操作类型 1 为 queries[i] = [1, l, r] 。你需要将 nums1 从下标 l 到下标 r 的所有 0 反转成 1 或将 1 反转成 0 。l 和 r 下标都从 0 开始。
操作类型 2 为 queries[i] = [2, p, 0] 。对于 0 <= i < n 中的所有下标，令 nums2[i] = nums2[i] + nums1[i] * p 。
操作类型 3 为 queries[i] = [3, 0, 0] 。求 nums2 中所有元素的和。

请你返回一个数组，包含所有第三种操作类型的答案。

预备知识

类似的区间求和问题，我们先回顾一下解决方案：

1、静态数组求区间和：「前缀和数组」、「树状数组」、「线段树」
2、频繁单点更新，求区间和：「树状数组」、「线段树」
3、频繁区间更新，求具体位置：「差分数组」
4、频繁区间更新，求区间和：「线段树 + 懒更新」

这道题涉及 “区间更新” 和 “区间求和”，所以属于线段树的典型例题。

题解一（朴素线段树）

我们先理解题目中三种操作的含义：

操作一：对 nums1 数组中位于 [left, right] 区间的数进行反转，也就是进行 “区间更新”；
操作二：将 nums1 数组上的数值 nums1[index] 乘以 p 后累加到 nums2 数组的相同位置上，即 nums2[index] += nums1[index] * p，同样也是进行 “区间更新”；
操作三：求 nums2 数组中所有元素和，即 “求区间和”。

OK，既然操作一和操作二是对不同数组进行 “区间更新”，那么我们需要分别为这两个数组建立线段树吗？并不需要，这是题目抛出的烟雾弹。

因为题目最终的解是求 nums2 数组的全体和，所以我们并不需要真正地维护 nums2 数组，只需要将操作二的增量累加到全体和中。这样的话就是只需要维护 nums1 数组的线段树。

理解题意后，我们可以写出题解的主框架：

1、首先计算 nums2 数组的初始全体和 sum；
2、建立 nums1 数组的线段树；
3、依次处理每种操作，操作一对线段树做区间更新，操作二对线段树做区间求和后乘以 p，并累加到全体和 sum 中，操作三将 sum 推入结果列表。

// 程序主框架
class Solution {
    fun handleQuery(nums1: IntArray, nums2: IntArray, queries: Array<IntArray>): LongArray {
        val n = nums1.size
        val resultList = LinkedList<Long>()
        // 全体和
        var sum = 0L
        for (num in nums2) {
            sum += num
        }
                val tree = SegementTree(nums1)
        for (query in queries) {
            when (query[0]) {
                1 -> {
                    // 区间更新
                    tree.update(query[1], query[2])
                }
                2 -> {
                    // 求区间和（nums[index] * p）
                    sum += 1L * query[1] * tree.query(0, n - 1)
                }
                3 -> {
                    // 记录
                    resultList.add(sum)
                }
            }
        }
        return resultList.toLongArray()
    }

    private class SegementTree(private val data: IntArray) {

        // 区间更新（反转）
        fun update(left: Int, right: Int) {

        }

        // 单点更新（反转）- 本题不需要
        fun set(pos: Int) {

        }

        // 区间查询
        fun query(left: Int, right: Int): Int {

        }
    }
}

接下来就是实现线段树的内部代码了。

技巧 1：这道题的更新操作是对 0/ 1 反转，我们可以用异或来实现；
技巧 2：相对于在函数中重复传递节点所代表的区间范围（例如 update(i: int, l: int, r: int, L: int, R: int)），使用 Node 节点记录更为方便。

class Solution {
    fun handleQuery(nums1: IntArray, nums2: IntArray, queries: Array<IntArray>): LongArray {
        val n = nums1.size
        val resultList = LinkedList<Long>()
        // 全体和
        var sum = 0L
        for (num in nums2) {
            sum += num
        }
        val tree = SegementTree(nums1)
        for (query in queries) {
            when (query[0]) {
                1 -> {
                    // 区间更新
                    tree.update(query[1], query[2])
                }
                2 -> {
                    // 求区间和（nums[index] * p）
                    sum += 1L * query[1] * tree.query(0, n - 1)
                }
                3 -> {
                    // 记录
                    resultList.add(sum)
                }
            }
        }
        return resultList.toLongArray()
    }

    private class SegementTree(private val data: IntArray) {
        // 线段树节点（区间范围与区间值）
        private class Node(val left: Int, val right: Int, var value: Int)

        // 线段树数组
        private val tree = Array<Node?>(4 * data.size) { null } as Array<Node>

        // 左子节点的索引
        private val Int.left get() = this * 2 + 1

        // 右子节点的索引
        private val Int.right get() = this * 2 + 2

        init {
            // 建树
            buildNode(0, 0, data.size - 1)
        }

        // 构建线段树节点
        private fun buildNode(index: Int, left: Int, right: Int) {
            if (left == right) {
                // 叶子节点
                tree[index] = Node(left, right, data[left])
                return
            }
            val mid = (left + right) ushr 1
            // 构建左子节点
            buildNode(index.left, left, mid)
            // 构建左子节点
            buildNode(index.right, mid + 1, right)
            // 合并左右子节点
            tree[index] = Node(left, right, tree[index.left].value + tree[index.right].value)
        }

        // 区间更新（反转）
        fun update(left: Int, right: Int) {
            update(0, left, right)
        }

        // 区间更新（反转）
        private fun update(index: Int, left: Int, right: Int) {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > right || tree[index].right < left) return
            // 2、叶子节点
            if (tree[index].left == tree[index].right) {
                // 反转：0->1,1->0
                tree[index].value = tree[index].value xor 1
                return
            }
            // 3、更新左子树
            update(index.left, left, right)
            // 4、更新右子树
            update(index.right, left, right)
            // 5、合并子节点的结果
            tree[index].value = tree[index.left].value + tree[index.right].value
        }

        // 单点更新（反转）- 本题不需要
        fun set(pos: Int) {
            set(0, pos)
        }

        // 单点更新（反转）- 本题不需要
        private fun set(index: Int, pos: Int) {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > pos || tree[index].right < pos) return
            // 2、叶子节点
            if (tree[index].left == tree[index].right) {
                // 反转：0->1,1->0
                tree[index].value = tree[index].value xor 1
                return
            }
            // 3、更新左子树
            set(index.left, pos)
            // 4、更新右子树
            set(index.right, pos)
            // 5、合并子节点的结果
            tree[index].value = tree[index.left].value + tree[index.right].value
        }

        // 区间查询
        fun query(left: Int, right: Int): Int {
            return query(0, left, right)
        }

        // 区间查询
        private fun query(index: Int, left: Int, right: Int): Int {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > right || tree[index].right < left) return 0
            // 2、当前节点完全处于区间范围之内
            if (tree[index].left >= left && tree[index].right <= right) return tree[index].value
            // 3、合并子节点的结果
            return query(index.left, left, right) + query(index.right, left, right)
        }
    }
}

复杂度分析：

时间复杂度： $O(n + q_1n + q_2)$ 其中 n 是 nums1 数组长度， $q_1$ 是操作一的个数， $q_2$ 是操作二的个数。我们需要花费 $O(n)$ 时间建树，操作一线段树区间更新的时间复杂度是 $O(n)$ ，操作二线段树区间查询的复杂度是 $O(lgn)$ ，但本题中的查询正好是线段树根节点，所以操作二实际上只需要 $O(1)$ 复杂度。
空间复杂度： $O(n)$ 线段树空间。

朴素线段树解法在本题中会超时，我们需要优化为 “懒更新” 的线段树实现。

题解二（线段树 + 懒更新）

朴素线段树的性能瓶颈在于：区间更新需要改动从根节点到叶子节点中所有与目标区间有交集的节点，因此单次区间更新操作的时间复杂度是 $O(n)$ 。

懒更新线段树的核心思想是：当一个节点代表的区间完全包含于目标区间内时，我们没有必要继续向下递归更新，而是在当前节点上标记 Lazy Tag 。只有将来更新该节点的某个子区间时，才会将懒更新 pushdown 到子区间。

举个例子：在长度为 10 的线段树中执行 [1,10] 和 [1,5] 两次区间更新操作（对区间内的元素加一）：

[1,10] 区间更新：从根节点出发，此时发现根节点与目标区间 [1,10] 完全相同，那么只更新根节点并标记 Lazy Tag，更新结束；
[1,5] 区间更新：从根节点出发，此时发现根节点有 Lazy Tag，那么需要先将懒更新 pushdown 到 [1,5] 和 [6,10] 两个子节点，然后再更新 [1,5] 区间。
到目前为止，[1,10] 和 [1,5] 节点被修改 2 次，[6,10] 节点被修改 1 次，其它节点没有被修改。

接下来就是实现线段树的内部代码了。

技巧 1：0 /1 反转是负负得正的，所以 Lazy Tag 可以用 Boolean 类型表示，true 表示被反转；
技巧 2：区间反转可以用区间长度 - 旧值实现，即：value = right - left + 1 - value。

提示：相比题解一改动的函数有【懒更新】标记。

class Solution {
    fun handleQuery(nums1: IntArray, nums2: IntArray, queries: Array<IntArray>): LongArray {
        val n = nums1.size
        val resultList = LinkedList<Long>()
        // 全体和
        var sum = 0L
        for (num in nums2) {
            sum += num
        }
        val tree = LazySegementTree(nums1)
        for (query in queries) {
            when (query[0]) {
                1 -> {
                    // 区间更新
                    tree.update(query[1], query[2])
                }
                2 -> {
                    // 求区间和（nums[index] * p）
                    sum += 1L * query[1] * tree.query(0, n - 1)
                }
                3 -> {
                    // 记录
                    resultList.add(sum)
                }
            }
        }
        return resultList.toLongArray()
    }

    private class LazySegementTree(private val data: IntArray) {
        // 线段树节点（区间范围与区间值）【懒更新】
        private class Node(val left: Int, val right: Int, var value: Int, var lazy: Boolean = false)

        // 线段树数组
        private val tree = Array<Node?>(4 * data.size) { null } as Array<Node>

        // 左子节点的索引
        private val Int.left get() = this * 2 + 1

        // 右子节点的索引
        private val Int.right get() = this * 2 + 2

        init {
            // 建树
            buildNode(0, 0, data.size - 1)
        }

        // 构建线段树节点
        private fun buildNode(index: Int, left: Int, right: Int) {
            if (left == right) {
                // 叶子节点
                tree[index] = Node(left, right, data[left])
                return
            }
            val mid = (left + right) ushr 1
            // 构建左子节点
            buildNode(index.left, left, mid)
            // 构建左子节点
            buildNode(index.right, mid + 1, right)
            // 合并左右子节点
            tree[index] = Node(left, right, tree[index.left].value + tree[index.right].value)
        }

        // 区间更新（反转）
        fun update(left: Int, right: Int) {
            update(0, left, right)
        }

        // 区间更新（反转）【懒更新】
        private fun update(index: Int, left: Int, right: Int) {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > right || tree[index].right < left) return
            // 2、当前节点完全处于区间范围之内
            if (tree[index].left >= left && tree[index].right <= right) {
                lazyUpdate(index)
                return
            }
            // 3、pushdown 到子节点
            if (tree[index].lazy) {
                lazyUpdate(index.left)
                lazyUpdate(index.right)
                tree[index].lazy = false
            }
            // 4、更新左子树
            update(index.left, left, right)
            // 5、更新右子树
            update(index.right, left, right)
            // 6、合并子节点的结果
            tree[index].value = tree[index.left].value + tree[index.right].value
        }

        // 单点更新（反转）- 本题不需要
        fun set(pos: Int) {
            set(0, pos)
        }

        // 单点更新（反转）【懒更新】- 本题不需要
        private fun set(index: Int, pos: Int) {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > pos || tree[index].right < pos) return
            // 2、叶子节点
            if (tree[index].left == tree[index].right) {
                lazyUpdate(index)
                return
            }
            // 3、pushdown 到子节点
            if (tree[index].lazy) {
                lazyUpdate(index.left)
                lazyUpdate(index.right)
                tree[index].lazy = false
            }
            // 4、更新左子树
            set(index.left, pos)
            // 5、更新右子树
            set(index.right, pos)
            // 6、合并子节点的结果
            tree[index].value = tree[index.left].value + tree[index.right].value
        }

        // 区间查询
        fun query(left: Int, right: Int): Int {
            return query(0, left, right)
        }

        // 区间查询
        private fun query(index: Int, left: Int, right: Int): Int {
            // 1、当前节点不处于区间范围内
            if (tree[index].left > right || tree[index].right < left) return 0
            // 2、当前节点完全处于区间范围之内
            if (tree[index].left >= left && tree[index].right <= right) return tree[index].value
            // 3、pushdown 到子节点
            if (tree[index].lazy) {
                lazyUpdate(index.left)
                lazyUpdate(index.right)
                tree[index].lazy = false
            }
            // 4、合并子节点的结果
            return query(index.left, left, right) + query(index.right, left, right)
        }

        // 懒更新
        private fun lazyUpdate(index: Int) {
            // 反转
            tree[index].value = tree[index].right - tree[index].left + 1 - tree[index].value
            // 标记（负负得正）
            tree[index].lazy = !tree[index].lazy
        }
    }
}

复杂度分析：

时间复杂度： $O(n + q_1lgn + q_2)$ 其中 n 是 nums1 数组长度， $q_1$ 是操作一的个数， $q_2$ 是操作二的个数。
空间复杂度： $O(n)$ 线段树空间。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,029评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,395评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,570评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,535评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,650评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,850评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,006评论 3赞 408
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,747评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,207评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,536评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,683评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,342评论 4赞 330
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,964评论 3赞 315
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,772评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,004评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,401评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,566评论 2赞 349

LeetCode 双周赛 98，脑筋急转弯转不过来！

2566. 替换一个数字后的最大差值（Easy）

题目地址

题目描述

题解（字符串操作）

2567. 修改两个元素的最小分数（Medium)

题目地址

题目描述

题解（排序 + 枚举）

2568. 最小无法得到的或值（Medium）

题目地址

题目描述

题解一（散列表）

题解二（位运算）

2569. 更新数组后处理求和查询（Hard）

题目地址

题目描述

预备知识

题解一（朴素线段树）

题解二（线段树 + 懒更新）

推荐阅读更多精彩内容