月度归档： 2024 年 10 月

目标

给你一个整数数组 nums，和一个整数 k 。

对于每个下标 i（0 <= i < nums.length），将 nums[i] 变成 nums[i] + k 或 nums[i] - k 。

nums 的 分数 是 nums 中最大元素和最小元素的差值。

在更改每个下标对应的值之后，返回 nums 的最小 分数 。

示例 1：

输入：nums = [1], k = 0
输出：0
解释：分数 = max(nums) - min(nums) = 1 - 1 = 0 。

示例 2：

输入：nums = [0,10], k = 2
输出：6
解释：将数组变为 [2, 8] 。分数 = max(nums) - min(nums) = 8 - 2 = 6 。

示例 3：

输入：nums = [1,3,6], k = 3
输出：3
解释：将数组变为 [4, 6, 3] 。分数 = max(nums) - min(nums) = 6 - 3 = 3 。

说明：

• 1 <= nums.length <= 10^4
• 0 <= nums[i] <= 10^4
• 0 <= k <= 10^4

思路

这道题与 908.最小差值I 的区别是对于每个元素操作是 必选的，增加或减少的值 固定 为 k 而不是区间 [-k, k]。

每个元素都可以取 nums[i] + k 或 nums[i] - k，如果枚举所有可能的数组，然后再取最大最小值差的最小值显然是不可能的。不考虑重复元素的情况下，可能的数组有 2^n 种。

可以先排序，增大小的值，减少大的值，枚举二者的边界，比如前 i 个元素 [0, i - 1] 加 k，剩余元素减 k，这时上界为 Math.max(nums[i - 1] + k, nums[n - 1] - k) ，下界为 Math.min(nums[0] + k, nums[i] - k)，取上下界的最小值即可。

代码

/**
 * @date 2024-10-21 9:57
 */
public class SmallestRangeII910 {

    public int smallestRangeII(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length;
        int res = nums[n - 1] - nums[0];
        for (int i = 1; i < n; i++) {
            int max = Math.max(nums[i - 1] + k, nums[n - 1] - k);
            int min = Math.min(nums[0] + k, nums[i] - k);
            res = Math.min(res, max - min);
        }
        return res;
    }

}

性能

目标

给你一个二进制数组 nums 。

你可以对数组执行以下操作 任意 次（也可以 0 次）：

• 选择数组中 任意 一个下标 i ，并将从下标 i 开始一直到数组末尾 所有 元素 反转 。

反转 一个元素指的是将它的值从 0 变 1 ，或者从 1 变 0 。

请你返回将 nums 中所有元素变为 1 的 最少 操作次数。

示例 1：

输入：nums = [0,1,1,0,1]
输出：4
解释：
我们可以执行以下操作：
选择下标 i = 1 执行操作，得到 nums = [0,0,0,1,0] 。
选择下标 i = 0 执行操作，得到 nums = [1,1,1,0,1] 。
选择下标 i = 4 执行操作，得到 nums = [1,1,1,0,0] 。
选择下标 i = 3 执行操作，得到 nums = [1,1,1,1,1] 。

示例 2：

输入：nums = [1,0,0,0]
输出：1
解释：
我们可以执行以下操作：
选择下标 i = 1 执行操作，得到 nums = [1,1,1,1] 。

说明：

• 1 <= nums.length <= 10^5
• 0 <= nums[i] <= 1

思路

有一个二进制数组 nums，每一次操作可以将当前元素以及之后的元素反转，问将所有元素变为 1 的最少操作次数。

这与昨天的题目 3191.使二进制数组全部等于1的最少操作次数I 类似，那个是将当前元素及后面两个元素反转。

还沿用昨天的思路，遇到 0 就进行操作，每一次操作需要对大量元素进行取模运算，因此考虑使用差分数组。这里差分数组初始均为 0，每次操作是针对当前元素及以后的所有元素，无需考虑后续的减法操作，因此只需要一个变量计数即可。

网友最快的算法并非使用变量计数然后判断奇偶性，考虑到最终目标是将所有元素都变为 1，每一次操作会将自身与其后的元素反转，对于初始数组任意位置 i，如果它为 0，该位置一定需要执行奇数次操作，因为执行偶数次反转最后还是 0。同理，如果为 1，需要执行 偶数 次操作。实际上每个位置是否需要执行操作是 确定的。

只要有一个初始条件，向后遍历的时候直接根据前一个元素与当前元素的关系判断是否需要累加操作即可，具体来说，如果它们值相同则不需要操作，如果不同则需要操作，直接累加这两个元素的异或值即可。

代码

/**
 * @date 2024-10-19 17:30
 */
public class MinOperations3192 {

    public int minOperations_v2(int[] nums) {
        int n = nums.length;
        int prev = nums[0];
        int res = prev ^ 1;
        for (int i = 1; i < n; i++) {
            res += prev ^ nums[i];
            prev = nums[i];
        }
        return res;
    }

    public int minOperations_v1(int[] nums) {
        int n = nums.length;
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (((res % 2 ^ nums[i]) == 0)) {
                res++;
            }
        }
        return res;
    }

}

性能

目标

给你 2 枚相同 的鸡蛋，和一栋从第 1 层到第 n 层共有 n 层楼的建筑。

已知存在楼层 f ，满足 0 <= f <= n ，任何从 高于 f 的楼层落下的鸡蛋都 会碎 ，从 f 楼层或比它低 的楼层落下的鸡蛋都 不会碎 。

每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层 x 扔下（满足 1 <= x <= n）。如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。

请你计算并返回要确定 f 确切的值 的 最小操作次数 是多少？

示例 1：

输入：n = 2
输出：2
解释：我们可以将第一枚鸡蛋从 1 楼扔下，然后将第二枚从 2 楼扔下。
如果第一枚鸡蛋碎了，可知 f = 0；
如果第二枚鸡蛋碎了，但第一枚没碎，可知 f = 1；
否则，当两个鸡蛋都没碎时，可知 f = 2。

示例 2：

输入：n = 100
输出：14
解释：
一种最优的策略是：
- 将第一枚鸡蛋从 9 楼扔下。如果碎了，那么 f 在 0 和 8 之间。将第二枚从 1 楼扔下，然后每扔一次上一层楼，在 8 次内找到 f 。总操作次数 = 1 + 8 = 9 。
- 如果第一枚鸡蛋没有碎，那么再把第一枚鸡蛋从 22 层扔下。如果碎了，那么 f 在 9 和 21 之间。将第二枚鸡蛋从 10 楼扔下，然后每扔一次上一层楼，在 12 次内找到 f 。总操作次数 = 2 + 12 = 14 。
- 如果第一枚鸡蛋没有再次碎掉，则按照类似的方法从 34, 45, 55, 64, 72, 79, 85, 90, 94, 97, 99 和 100 楼分别扔下第一枚鸡蛋。
不管结果如何，最多需要扔 14 次来确定 f 。

说明：

• 1 <= n <= 1000

思路

有一个 1 ~ n 层楼的建筑，存在一个楼层 f，任何大于 f 层落下的鸡蛋都会摔碎。现在有两个鸡蛋，每次操作可以从任意楼层向下扔鸡蛋，如果鸡蛋碎了则无法再使用，求确定 f 值的最小操作次数。

为了确保能够找到 f，如果第一个尝试的鸡蛋碎了，那么另一个鸡蛋只能从已知的安全楼层一层一层向上尝试。

观察示例2，可以从 n 开始 减 1 2 3 …… i 直到小于等于零，返回 i - 1即可。

看了题解，这样做可行的逻辑是这样的：

假设已知最小操作次数 k，我们扔第一枚鸡蛋选第几层？显然，应该选第 k 层，因为如果第一枚鸡蛋碎了，只需要从 1 ~ k - 1 枚举即可。

如果第一枚鸡蛋没碎，那么下一次选第几层？现在还剩下 k - 1 次尝试，所以应该选 k + 1 + (k - 2) = k + (k - 1) 层，因为如果在该层扔鸡蛋碎了，只需从 k + 1 ~ k + k - 2 枚举即可，共 k - 2 次，再加上前面尝试的 2 次，总次数为 k。

以此类推，我们可以确定总层数 n = k + (k - 1) + (k - 2) + …… + 2 + 1 = k * (k + 1)/2，解方程得 k = (sqrt(1+8*n) - 1)/2，结果需要向上取整。

代码

/**
 * @date 2024-10-13 19:30
 */
public class TwoEggDrop1884 {

    public int twoEggDrop_v1(int n) {
        return (int) Math.ceil((Math.sqrt(1 + 8 * n) - 1) / 2);
    }

    public int twoEggDrop(int n) {
        int i = 1;
        while (n > 0){
            n -= i++;
        }
        return i - 1;
    }
}

性能