LeetCode Weekly Contest 202

5185. 存在连续三个奇数的数组

给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况。
示例 2：

输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

提示：

1 <= arr.length <= 1000
1 <= arr[i] <= 1000

代码

class Solution {
    public boolean threeConsecutiveOdds(int[] arr) {
        int cnt = 0;
        for (int num: arr) {
            if (num % 2 == 1) {
                ++cnt;
                if (cnt == 3) {
                    return true;
                }
            } else {
                cnt = 0;
            }
        }
        return false;
    }
}

5488. 使数组中所有元素相等的最小操作数

存在一个长度为 n 的数组 arr ，其中 arr[i] = (2 * i) + 1 （ 0 <= i < n ）。

一次操作中，你可以选出两个下标，记作 x 和 y （ 0 <= x, y < n ）并使 arr[x] 减去 1 、arr[y] 加上 1 （即 arr[x] -=1 且 arr[y] += 1 ）。最终的目标是使数组中的所有元素都 相等 。题目测试用例将会 保证 ：在执行若干步操作后，数组中的所有元素最终可以全部相等。

给你一个整数 n，即数组的长度。请你返回使数组 arr 中所有元素相等所需的 最小操作数 。

示例 1：

输入：n = 3
输出：2
解释：arr = [1, 3, 5]
第一次操作选出 x = 2 和 y = 0，使数组变为 [2, 3, 4]
第二次操作继续选出 x = 2 和 y = 0，数组将会变成 [3, 3, 3]
示例 2：

输入：n = 6
输出：9

提示：

1 <= n <= 10^4

思路

数学题，分奇偶讨论，等差数列求和公式

代码

class Solution {
    public int minOperations(int n) {
        return n % 2 == 1? (n*n-1)/4: n*n/4;
    }
}

5489. 两球之间的磁力

在代号为 C-137 的地球上，Rick 发现如果他将两个球放在他新发明的篮子里，它们之间会形成特殊形式的磁力。Rick 有 n 个空的篮子，第 i 个篮子的位置在 position[i] ，Morty 想把 m 个球放到这些篮子里，使得任意两球间 最小磁力 最大。

已知两个球如果分别位于 x 和 y ，那么它们之间的磁力为 |x - y| 。

给你一个整数数组 position 和一个整数 m ，请你返回最大化的最小磁力。

示例 1：

输入：position = [1,2,3,4,7], m = 3
输出：3
解释：将 3 个球分别放入位于 1，4 和 7 的三个篮子，两球间的磁力分别为 [3, 3, 6]。最小磁力为 3 。我们没办法让最小磁力大于 3 。
示例 2：

输入：position = [5,4,3,2,1,1000000000], m = 2
输出：999999999
解释：我们使用位于 1 和 1000000000 的篮子时最小磁力最大。

提示：

n == position.length
2 <= n <= 10^5
1 <= position[i] <= 10^9
所有 position 中的整数 互不相同 。
2 <= m <= position.length

思路

『最大最小问题』用二分搜索答案。假设position[i]的上限为N, position长度为n，则时间复杂度为O(nlogN).

代码

class Solution {
    private boolean isValid(int target, int[] gaps, int m) {
        int i = 0, n = gaps.length, len = 0, cnt = 0;
        while (i < n) {
            len += gaps[i++];
            if (len >= target) {
                len = 0;
                ++cnt;
            }
        }
        return cnt >= m;
    }
    
    public int maxDistance(int[] position, int m) {
        Arrays.sort(position);
        int n = position.length, i = 0, minGap = Integer.MAX_VALUE, maxGap = position[n-1] - position[0];
        int[] gaps = new int[n-1];
        for (i=0; i<n-1; ++i) {
            gaps[i] = position[i+1] - position[i];
            minGap = Math.min(minGap, gaps[i]);
        }
        int left = minGap, right = maxGap, mid = 0;
        while (left <= right) {
            mid = (right - left) / 2 + left;
            if (isValid(mid, gaps, m-1)) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return right;
    }
}

5490. 吃掉 N 个橘子的最少天数

厨房里总共有 n 个橘子，你决定每一天选择如下方式之一吃这些橘子：

吃掉一个橘子。
如果剩余橘子数 n 能被 2 整除，那么你可以吃掉 n/2 个橘子。
如果剩余橘子数 n 能被 3 整除，那么你可以吃掉 2*(n/3) 个橘子。
每天你只能从以上 3 种方案中选择一种方案。

请你返回吃掉所有 n 个橘子的最少天数。

示例 1：

输入：n = 10
输出：4
解释：你总共有 10 个橘子。
第 1 天：吃 1 个橘子，剩余橘子数 10 - 1 = 9。
第 2 天：吃 6 个橘子，剩余橘子数 9 - 2*(9/3) = 9 - 6 = 3。（9 可以被 3 整除）
第 3 天：吃 2 个橘子，剩余橘子数 3 - 2*(3/3) = 3 - 2 = 1。
第 4 天：吃掉最后 1 个橘子，剩余橘子数 1 - 1 = 0。
你需要至少 4 天吃掉 10 个橘子。
示例 2：

输入：n = 6
输出：3
解释：你总共有 6 个橘子。
第 1 天：吃 3 个橘子，剩余橘子数 6 - 6/2 = 6 - 3 = 3。（6 可以被 2 整除）
第 2 天：吃 2 个橘子，剩余橘子数 3 - 2*(3/3) = 3 - 2 = 1。（3 可以被 3 整除）
第 3 天：吃掉剩余 1 个橘子，剩余橘子数 1 - 1 = 0。
你至少需要 3 天吃掉 6 个橘子。
示例 3：

输入：n = 1
输出：1
示例 4：

输入：n = 56
输出：6

提示：

1 <= n <= 2*10^9

思路

贪心 + 记忆化搜索。
贪心：本来应该是
minDays(n) = min(minDays(n-1), minDays(n/2)[if n % 2 == 0], minDays(n/3)[if n % 3 == 0])
用贪心变成
minDays(n) = min(minDays(n/2) + n % 2, minDays(n/3) + n % 3) + 1

记忆化搜索：直接开2*10^9长度的dp数组会超出空间限制，用HashMap保存中间结果，因为[1, n)中的大部分数不会被遍历到。

代码

class Solution {
    private HashMap<Integer, Integer> cache = new HashMap<>();
    
    public int minDays(int n) {
        if (n <= 2) {
            return n;
        }
        if (cache.containsKey(n)) {
            return cache.get(n);
        }
        int ret = Math.min(minDays(n/2) + n % 2, minDays(n/3) + n % 3);
        cache.put(n, ret + 1);
        return ret + 1;
    }
}