Leetcode 第 202 场周赛

感觉就是拼手速的比赛，没什么意思，再打几次把排名打到前面就不打了。

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

class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int len = arr.size();
        for(int i = 0;i < len - 2;i++) {
            if(arr[i] % 2 == 1 && arr[i + 1] % 2 == 1 && arr[i + 2] % 2 == 1) {
                return true;
            }
        }
        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 中所有元素相等所需的 最小操作数 。

class Solution {
public:
    int minOperations(int n) {
        int mid = 0;
        if(n & 1) {
            mid = n / 2 * 2 + 1;
        } else {
            mid = (1 + (n - 1) * 2 + 1) / 2;
        }
        int ans = 0;
        for(int i = 0;i < n;i++) {
            int now = i * 2 + 1;
            ans += abs(now - mid);
        }
        return ans / 2;
    }
};

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

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

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

思路：
直接二分就好了

class Solution {
public:
    int check(int mid,vector<int>&position,int m) {
        int n = position.size();
        int pre = position[0];
        int cnt = 1;
        for(int i = 1;i < n;i++) {
            if(position[i] - pre >= mid) {
                cnt++;
                pre = position[i];
            }
        }
        return cnt >= m;
    }
    
    int maxDistance(vector<int>& position, int m) {
        sort(position.begin(),position.end());
        int l = 0,r = 1e9;
        int ans = 0;
        while(l <= r) {
            int mid = (l + r) >> 1;
            if(check(mid,position,m)) {
                ans = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return ans;
    }
};

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

思路：
这个题还挺有意思的。DP方程不难想到，就是这样记忆化搜索嘛。但是理论上每个点有3个子状态，最多可以有20层，那不是早就爆了吗。

不过事实上加上记忆化后状态很少，很容易就可以搜到结果了。感觉特别迷惑

class Solution {
public:
    map<int,int>mp;
    int DP(int n) {
        if(mp[n]) return mp[n];
        if(n <= 2) return n;
        if(n == 3) return 2;
        int x1 = n % 2,x2 = n % 3;
        mp[n] = min(DP((n - x1) / 2) + x1,DP((n - x2) / 3) + x2) + 1;
        return mp[n];
    }
    int minDays(int n) {
        return DP(n);
    }
};